diff --git a/.gitignore b/.gitignore index 90676451b..6b51612cc 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,4 @@ bin/ target/ .metadata/ .recommenders/ -*.cryptslbin \ No newline at end of file +*.cryslbin \ No newline at end of file diff --git a/features/de.cognicrypt.codegenerator.feature/.project b/features/de.cognicrypt.codegenerator.feature/.project index f9e0644fb..9df1e0850 100644 --- a/features/de.cognicrypt.codegenerator.feature/.project +++ b/features/de.cognicrypt.codegenerator.feature/.project @@ -1,17 +1,17 @@ - - - de.cognicrypt.codegenerator.feature - - - - - - org.eclipse.pde.FeatureBuilder - - - - - - org.eclipse.pde.FeatureNature - - + + + de.cognicrypt.codegenerator.feature + + + + + + org.eclipse.pde.FeatureBuilder + + + + + + org.eclipse.pde.FeatureNature + + diff --git a/features/de.cognicrypt.codegenerator.feature/pom.xml b/features/de.cognicrypt.codegenerator.feature/pom.xml index 510f4b72f..6bc54d27e 100644 --- a/features/de.cognicrypt.codegenerator.feature/pom.xml +++ b/features/de.cognicrypt.codegenerator.feature/pom.xml @@ -1,13 +1,12 @@ - - 4.0.0 - de.cognicrypt.codegenerator.feature - eclipse-feature - - de.cognicrypt - de.cognicrypt.parent - 1.0.0-SNAPSHOT - ../../pom.xml - - de.cognicrypt - + + 4.0.0 + de.cognicrypt.codegenerator.feature + eclipse-feature + + de.cognicrypt + de.cognicrypt.parent + 1.0.0-SNAPSHOT + ../../pom.xml + + diff --git a/features/de.cognicrypt.core.feature/pom.xml b/features/de.cognicrypt.core.feature/pom.xml index d26c0367b..9d403a783 100644 --- a/features/de.cognicrypt.core.feature/pom.xml +++ b/features/de.cognicrypt.core.feature/pom.xml @@ -1,13 +1,13 @@ - - 4.0.0 - de.cognicrypt.core.feature - eclipse-feature - - de.cognicrypt - de.cognicrypt.parent - 1.0.0-SNAPSHOT - ../../pom.xml - - de.cognicrypt - + + 4.0.0 + de.cognicrypt.core.feature + eclipse-feature + + de.cognicrypt + de.cognicrypt.parent + 1.0.0-SNAPSHOT + ../../pom.xml + + de.cognicrypt + diff --git a/features/de.cognicrypt.cryslhandler.feature/feature.xml b/features/de.cognicrypt.cryslhandler.feature/feature.xml index 04d14ef07..553770441 100644 --- a/features/de.cognicrypt.cryslhandler.feature/feature.xml +++ b/features/de.cognicrypt.cryslhandler.feature/feature.xml @@ -112,9 +112,9 @@ Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives n - - - + + + diff --git a/features/de.cognicrypt.cryslhandler.feature/pom.xml b/features/de.cognicrypt.cryslhandler.feature/pom.xml index ab875ef0e..0e88930ad 100644 --- a/features/de.cognicrypt.cryslhandler.feature/pom.xml +++ b/features/de.cognicrypt.cryslhandler.feature/pom.xml @@ -1,13 +1,12 @@ - - 4.0.0 - de.cognicrypt.cryslhandler.feature - eclipse-feature - - de.cognicrypt - de.cognicrypt.parent - 1.0.0-SNAPSHOT - ../../pom.xml - - de.cognicrypt - + + 4.0.0 + de.cognicrypt.cryslhandler.feature + eclipse-feature + + de.cognicrypt + de.cognicrypt.parent + 1.0.0-SNAPSHOT + ../../pom.xml + + diff --git a/features/de.cognicrypt.staticanalyzer.feature/.project b/features/de.cognicrypt.staticanalyzer.feature/.project index 5f9aee04a..a767ca842 100644 --- a/features/de.cognicrypt.staticanalyzer.feature/.project +++ b/features/de.cognicrypt.staticanalyzer.feature/.project @@ -1,17 +1,17 @@ - - - de.cognicrypt.staticanalyzer.feature - - - - - - org.eclipse.pde.FeatureBuilder - - - - - - org.eclipse.pde.FeatureNature - - + + + de.cognicrypt.staticanalyzer.feature + + + + + + org.eclipse.pde.FeatureBuilder + + + + + + org.eclipse.pde.FeatureNature + + diff --git a/features/de.cognicrypt.staticanalyzer.feature/pom.xml b/features/de.cognicrypt.staticanalyzer.feature/pom.xml index 3ffafc4ee..744a2c53b 100644 --- a/features/de.cognicrypt.staticanalyzer.feature/pom.xml +++ b/features/de.cognicrypt.staticanalyzer.feature/pom.xml @@ -1,13 +1,13 @@ - - 4.0.0 - de.cognicrypt.staticanalyzer.feature - eclipse-feature - - de.cognicrypt - de.cognicrypt.parent - 1.0.0-SNAPSHOT - ../../pom.xml - - de.cognicrypt - + + 4.0.0 + de.cognicrypt.staticanalyzer.feature + eclipse-feature + + de.cognicrypt + de.cognicrypt.parent + 1.0.0-SNAPSHOT + ../../pom.xml + + de.cognicrypt + diff --git a/plugins/de.cognicrypt.codegenerator.tests/.classpath b/plugins/de.cognicrypt.codegenerator.tests/.classpath index 9d329bd04..4433eb2fd 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/.classpath +++ b/plugins/de.cognicrypt.codegenerator.tests/.classpath @@ -1,6 +1,6 @@ - + diff --git a/plugins/de.cognicrypt.codegenerator.tests/META-INF/MANIFEST.MF b/plugins/de.cognicrypt.codegenerator.tests/META-INF/MANIFEST.MF index c8f747385..7dd04b39d 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/META-INF/MANIFEST.MF +++ b/plugins/de.cognicrypt.codegenerator.tests/META-INF/MANIFEST.MF @@ -1,11 +1,12 @@ -Manifest-Version: 1.0 -Bundle-ManifestVersion: 2 -Bundle-Name: CogniCrypt-CodeGenerator_Plug-inTests -Bundle-SymbolicName: de.cognicrypt.codegenerator.tests;singleton:=true -Bundle-Version: 1.0.0.qualifier -Fragment-Host: de.cognicrypt.codegenerator;bundle-version="1.0.0" -Require-Bundle: org.eclipse.jdt.launching, - de.cognicrypt.core -Bundle-RequiredExecutionEnvironment: JavaSE-1.8 -Bundle-ClassPath: lib/claferchocoig.jar,src/ -Export-Package: de.cognicrypt.codegenerator +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: CogniCrypt-CodeGenerator_Plug-inTests +Bundle-SymbolicName: de.cognicrypt.codegenerator.tests;singleton:=true +Bundle-Version: 1.0.0.qualifier +Fragment-Host: de.cognicrypt.codegenerator;bundle-version="1.0.0" +Require-Bundle: org.eclipse.jdt.launching, + de.cognicrypt.core +Bundle-RequiredExecutionEnvironment: JavaSE-1.8 +Bundle-ClassPath: lib/claferchocoig.jar,src/ +Export-Package: de.cognicrypt.codegenerator +Automatic-Module-Name: de.cognicrypt.codegenerator.tests diff --git a/plugins/de.cognicrypt.codegenerator.tests/build.properties b/plugins/de.cognicrypt.codegenerator.tests/build.properties index 92fad4a5a..d204fb770 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/build.properties +++ b/plugins/de.cognicrypt.codegenerator.tests/build.properties @@ -1,4 +1,3 @@ source.. = src/ -output.. = bin/ bin.includes = META-INF/,\ - lib/claferchocoig.jar,\ \ No newline at end of file + lib/claferchocoig.jar,\ diff --git a/plugins/de.cognicrypt.codegenerator.tests/pom.xml b/plugins/de.cognicrypt.codegenerator.tests/pom.xml index 7858c712f..1e4ca4cd4 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/pom.xml +++ b/plugins/de.cognicrypt.codegenerator.tests/pom.xml @@ -1,59 +1,59 @@ - - - 4.0.0 - - de.cognicrypt - de.cognicrypt.parent - 1.0.0-SNAPSHOT - ../../pom.xml - - - de.cognicrypt - de.cognicrypt.codegenerator.tests - eclipse-test-plugin - - - - - - org.eclipse.m2e - lifecycle-mapping - 1.0.0 - - - - - - org.codehaus.mojo - aspectj-maven-plugin - [1.0,) - - test-compile - compile - - - - - - - - - - - - org.eclipse.tycho - tycho-surefire-plugin - ${tycho-version} - - true - - - - - - - - - + + + 4.0.0 + + de.cognicrypt + de.cognicrypt.parent + 1.0.0-SNAPSHOT + ../../pom.xml + + + de.cognicrypt + de.cognicrypt.codegenerator.tests + eclipse-test-plugin + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.codehaus.mojo + aspectj-maven-plugin + [1.0,) + + test-compile + compile + + + + + + + + + + + + org.eclipse.tycho + tycho-surefire-plugin + ${tycho-version} + + true + + + + + + + + + diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CodeGenLocationSelectionTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CodeGenLocationSelectionTest.java new file mode 100644 index 000000000..3f7f14a8d --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CodeGenLocationSelectionTest.java @@ -0,0 +1,124 @@ +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import org.eclipse.core.resources.IResource; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.IPackageFragment; +import org.junit.Test; + +import de.cognicrypt.codegenerator.generator.CodeGenerator; +import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.wizard.CrySLConfiguration; +import de.cognicrypt.utils.DeveloperProject; + +public class CodeGenLocationSelectionTest { +// /** +// * Scenario: user doesn't select a specific class or package. +// * Expected behavior: CC generates its own package with the necessary classes +// * @throws Exception +// */ + @Test + public void noSpecificSelection() throws Exception { + // task + String template = "secretkeyencryption"; + // create Java project without any package or class + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject_SYMENC"); + // setup for code generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedProject.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(template, generatedProject.getResource(), + codeGenerator, developerProject); + // run code generation + boolean encCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + + assertTrue(encCheck); // check if code generation is successful + assertTrue(TestUtils.packageExists(generatedProject, Constants.PackageNameAsName)); // check if package is + // created + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); // check if Output.java is created + } + + /** + * Scenario: user selects just a package. Expected behavior: CC doesn't + * generates its own package just the necessary classes in the user selected + * package + * + * @throws Exception + */ + @Test + public void packageSelection() throws Exception { + // task + String template = "secretkeyencryption"; + + // package name + String packageName = "de.test.test"; + + // create Java project with package + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject_SYMENC"); + IPackageFragment generatedPackage = TestUtils.generatePackageInJavaProject(generatedProject, packageName); + + // setup for code generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedPackage.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(template, generatedPackage.getResource(), + codeGenerator, developerProject); + + // run code generation + boolean encCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + + assertTrue(encCheck); // check if code generation is successful + assertTrue(TestUtils.packageExists(generatedProject, Constants.PackageNameAsName)); // check if package is + // created + + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); // check if Output.java is created + } + + /** + * Case three: user selects one of his own classes. + * + * @throws Exception + */ + @Test + public void ownClassSelection() throws Exception { + // task + String template = "secretkeyencryption"; + + // create java project with a test class + IJavaProject generatedProject = TestUtils.createJavaProject(Constants.PROJECT_NAME); + IResource targetFile = TestUtils.generateJavaClassInJavaProject(generatedProject, Constants.PACKAGE_NAME, + Constants.CLASS_NAME); + // setup for code generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(targetFile); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(template, targetFile, codeGenerator, + developerProject); + // run code generation + boolean encCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + + assertTrue(encCheck); // check if code generation is successful + assertTrue(TestUtils.packageExists(generatedProject, Constants.PackageNameAsName)); // check if package is + // created + + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNull(outputClass); // check if Output.java is not created + } +} diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CodeGenOthersTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CodeGenOthersTest.java new file mode 100644 index 000000000..93fb10b1e --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CodeGenOthersTest.java @@ -0,0 +1,96 @@ +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.eclipse.jdt.core.IPackageFragment; +import org.junit.Test; + +import de.cognicrypt.codegenerator.generator.CodeGenerator; +import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.wizard.CrySLConfiguration; +import de.cognicrypt.utils.DeveloperProject; + +public class CodeGenOthersTest { + +// /** +// * Scenario: user doesn't select a specific class or package. +// * Expected behavior: CC generates its own package with the necessary classes +// * @throws Exception +// */ + @Test + public void noSpecificSelection() throws Exception { + //task + String template = "secretkeyencryption"; + // create Java project without any package or class + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject_SYMENC"); + // setup for code generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedProject.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(template, generatedProject.getResource(), + codeGenerator, developerProject); + // run code generation + boolean encCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + + assertTrue(encCheck); // check if code generation is successful + assertTrue(TestUtils.packageExists(generatedProject, Constants.PackageNameAsName)); // check if package is + // created + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); // check if Output.java is created + } + + + /** + * Scenario: user selects just a package. + * Expected behavior: CC doesn't generates its own package just the necessary classes in the user selected package + * @throws Exception + */ + @Test + public void packageSelection() throws Exception { + // task + String template = "secretkeyencryption"; + + // package name + String packageName = "de.test.test"; + + // create Java project with package + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject_SYMENC"); + IPackageFragment generatedPackage = TestUtils.generatePackageInJavaProject(generatedProject, packageName); + + // setup for code generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedPackage.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(template, generatedPackage.getResource(), + codeGenerator, developerProject); + + // run code generation + boolean encCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + + assertTrue(encCheck); // check if code generation is successful + assertTrue(TestUtils.packageExists(generatedProject, Constants.PackageNameAsName)); // check if package is created + + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); // check if Output.java is created + } + +// /** +// * Case three: user selects one of his own classes. +// * @throws Exception +// */ +// @Test +// public void ownClassSelection() throws Exception{ +// +// } +} \ No newline at end of file diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/Constants.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/Constants.java new file mode 100644 index 000000000..0c11776aa --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/Constants.java @@ -0,0 +1,9 @@ +package de.cognicrypt.codegenerator.generator.test; + +public class Constants { + public static final String PROJECT_NAME = "TestProject"; + public static final String PACKAGE_NAME = "testPackage"; + public static final String CLASS_NAME = "Test"; + public static final String JAVA_CLASS_NAME = "Test.java"; + public static final String PackageNameAsName = "de.cognicrypt.crypto"; +} diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CrySLCodeGenTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CrySLCodeGenTest.java index d8ddf6f0c..ad2f70a6c 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CrySLCodeGenTest.java +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/CrySLCodeGenTest.java @@ -32,7 +32,7 @@ public class CrySLCodeGenTest { @Test - public void generateSymEnc() throws IOException { + public void generateSymEnc() { String template = "secretkeyencryption"; try { IResource targetFile = TestUtils.generateJavaClassInJavaProject(TestUtils.createJavaProject("TestProject_SYMENC"), "testPackage", "Test"); @@ -60,6 +60,9 @@ public void generateSymEnc() throws IOException { catch (CoreException e) { Activator.getDefault().logError(e, "Failed to create test project or to retrieve compilation unit."); } + catch (IOException e) { + Activator.getDefault().logError(e, "Reading of at least one CrySL rule failed."); + } } @@ -269,8 +272,8 @@ public void generateHybridEncStrings() { assertEquals(4, TestUtils.countStatements(encClassUnit, "generateSessionKey")); assertEquals(5, TestUtils.countStatements(encClassUnit, "generateKeyPair")); assertEquals(7, TestUtils.countStatements(encClassUnit, "encryptSessionKey")); - assertEquals(15, TestUtils.countStatements(encClassUnit, "encryptData")); - assertEquals(13, TestUtils.countStatements(encClassUnit, "decryptData")); + assertEquals(14, TestUtils.countStatements(encClassUnit, "encryptData")); + assertEquals(12, TestUtils.countStatements(encClassUnit, "decryptData")); } catch (JavaModelException e) { Activator.getDefault().logError(e, "Could not create Java class in test project."); @@ -304,8 +307,8 @@ public void generateSecPwd() { ICompilationUnit encClassUnit = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, "PasswordHasher.java"); TestUtils.openJavaFileInWorkspace(developerProject, Constants.PackageName, encClassUnit); assertEquals(5, TestUtils.countMethods(encClassUnit)); - assertEquals(11, TestUtils.countStatements(encClassUnit, "createPWHash")); - assertEquals(10, TestUtils.countStatements(encClassUnit, "verifyPWHash")); + assertEquals(12, TestUtils.countStatements(encClassUnit, "createPWHash")); + assertEquals(11, TestUtils.countStatements(encClassUnit, "verifyPWHash")); } catch (JavaModelException e) { Activator.getDefault().logError(e, "Could not create Java class in test project."); @@ -335,11 +338,11 @@ public void generatedigSign() { TestUtils.openJavaFileInWorkspace(developerProject, "testPackage", testClassUnit); assertEquals(1, TestUtils.countMethods(testClassUnit)); - ICompilationUnit encClassUnit = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, "Signer.java"); + ICompilationUnit encClassUnit = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, "SecureSigner.java"); TestUtils.openJavaFileInWorkspace(developerProject, Constants.PackageName, encClassUnit); assertEquals(3, TestUtils.countMethods(encClassUnit)); assertEquals(5, TestUtils.countStatements(encClassUnit, "getKey")); - assertEquals(7, TestUtils.countStatements(encClassUnit, "sign")); + assertEquals(8, TestUtils.countStatements(encClassUnit, "sign")); // assertEquals(14, TestUtils.countStatements(encClassUnit, "vfy")); } catch (JavaModelException e) { diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/DigitalSignaturesCodeGenTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/DigitalSignaturesCodeGenTest.java new file mode 100644 index 000000000..f9a2c9d4a --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/DigitalSignaturesCodeGenTest.java @@ -0,0 +1,63 @@ +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.logging.Logger; + +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import de.cognicrypt.codegenerator.generator.CodeGenerator; +import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; +import de.cognicrypt.codegenerator.tasks.Task; +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.generator.test.Constants; +import de.cognicrypt.codegenerator.wizard.Configuration; +import de.cognicrypt.utils.DeveloperProject; + +/** + * @author Shahrzad Asghari + */ +public class DigitalSignaturesCodeGenTest { + private Logger log = Logger.getLogger(DigitalSignaturesCodeGenTest.class.getName()); + private IJavaProject testJavaProject; + private CodeGenerator generatorDigSignature; + private Task digSignatureTask; + private Configuration configDigSignature; + private DeveloperProject developerProject; + private IResource targetFile; + + @After + public void tearDown() throws CoreException { + TestUtils.deleteProject(this.testJavaProject.getProject()); + } + + @Before + public void setUp() throws Exception { + this.testJavaProject = TestUtils.createJavaProject(Constants.PROJECT_NAME); + targetFile = TestUtils.generateJavaClassInJavaProject(this.testJavaProject, Constants.PACKAGE_NAME, + Constants.CLASS_NAME); + this.digSignatureTask = TestUtils.getTask("DigitalSignatures"); + this.generatorDigSignature = new CrySLBasedCodeGenerator(targetFile); + this.developerProject = this.generatorDigSignature.getDeveloperProject(); + } + + @Test + public void testCodeGenerationDigSignatures() throws CoreException, IOException { + final ICompilationUnit testClassUnit = TestUtils.getICompilationUnit(this.developerProject, + Constants.PACKAGE_NAME, Constants.JAVA_CLASS_NAME); + TestUtils.openJavaFileInWorkspace(this.developerProject, Constants.PACKAGE_NAME, testClassUnit); + + this.configDigSignature = TestUtils.createCrySLConfiguration("digitalsignatures", testClassUnit.getResource(), + generatorDigSignature, this.developerProject); + final boolean encCheck = this.generatorDigSignature.generateCodeTemplates(this.configDigSignature, + this.digSignatureTask.getAdditionalResources()); + assertTrue(encCheck); + } +} diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/EncryptionCodeGenTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/EncryptionCodeGenTest.java new file mode 100644 index 000000000..51ae93fd8 --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/EncryptionCodeGenTest.java @@ -0,0 +1,120 @@ +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.logging.Logger; + +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import de.cognicrypt.codegenerator.generator.CodeGenerator; +import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; +import de.cognicrypt.codegenerator.tasks.Task; + +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.generator.test.Constants; +import de.cognicrypt.codegenerator.wizard.Configuration; +import de.cognicrypt.utils.DeveloperProject; + +/** + * @author Shahrzad Asghari + */ +public class EncryptionCodeGenTest { + + private Logger log = Logger.getLogger(EncryptionCodeGenTest.class.getName()); + private IJavaProject testJavaProject; + private CodeGenerator generatorEnc; + private Task encTask; + private Configuration configEnc; + private DeveloperProject developerProject; + private IResource targetFile; + private ICompilationUnit testClassUnit; + + @After + public void tearDown() throws CoreException { + TestUtils.deleteProject(this.testJavaProject.getProject()); + } + + @Before + public void setUp() throws Exception { + this.testJavaProject = TestUtils.createJavaProject(Constants.PROJECT_NAME); + targetFile = TestUtils.generateJavaClassInJavaProject(this.testJavaProject, Constants.PACKAGE_NAME, + Constants.CLASS_NAME); + this.encTask = TestUtils.getTask("Encryption"); + this.generatorEnc = new CrySLBasedCodeGenerator(targetFile); + this.developerProject = this.generatorEnc.getDeveloperProject(); + this.testClassUnit = TestUtils.getICompilationUnit(this.developerProject, Constants.PACKAGE_NAME, + Constants.JAVA_CLASS_NAME); + TestUtils.openJavaFileInWorkspace(this.developerProject, "testPackage", this.testClassUnit); + + } + + @Test + public void testCodeGenerationEncryption() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("encryption", testClassUnit.getResource(), generatorEnc, + this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } + + @Test + public void testCodeGenerationEncryptionHybrid() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("encryptionhybrid", testClassUnit.getResource(), + generatorEnc, this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } + + @Test + public void testCodeGenerationEncryptionFiles() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("encryptionfiles", testClassUnit.getResource(), + generatorEnc, this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } + + @Test + public void testCodeGenerationEncryptionHybridFiles() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("encryptionhybridfiles", testClassUnit.getResource(), + generatorEnc, this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } + + @Test + public void testCodeGenerationEncryptionHybridStrings() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("encryptionhybridstrings", testClassUnit.getResource(), + generatorEnc, this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } + + @Test + public void testCodeGenerationEncryptionStrings() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("encryptionstrings", testClassUnit.getResource(), + generatorEnc, this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } + + @Test + public void testCodeGenerationSecretKeyEncryption() throws CoreException, IOException { + this.configEnc = TestUtils.createCrySLConfiguration("secretkeyencryption", testClassUnit.getResource(), + generatorEnc, this.developerProject); + final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, + this.encTask.getAdditionalResources()); + assertTrue(encCheck); + } +} \ No newline at end of file diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/GenerationTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/GenerationTest.java deleted file mode 100644 index 86df64d5c..000000000 --- a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/GenerationTest.java +++ /dev/null @@ -1,143 +0,0 @@ -/******************************************************************************** - * Copyright (c) 2015-2019 TU Darmstadt, Paderborn University - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v. 2.0 which is available at - * http://www.eclipse.org/legal/epl-2.0. - * - * SPDX-License-Identifier: EPL-2.0 - ********************************************************************************/ - -package de.cognicrypt.codegenerator.generator.test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import java.io.IOException; -import java.util.logging.Logger; -import org.eclipse.core.resources.IFile; -import org.eclipse.core.resources.IResource; -import org.eclipse.core.runtime.CoreException; -import org.eclipse.jdt.core.ICompilationUnit; -import org.eclipse.jdt.core.IJavaProject; -import org.eclipse.jdt.core.JavaModelException; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import de.cognicrypt.codegenerator.generator.CodeGenerator; -import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; -import de.cognicrypt.codegenerator.generator.XSLBasedGenerator; -import de.cognicrypt.codegenerator.tasks.Task; -import de.cognicrypt.codegenerator.testutilities.TestUtils; -import de.cognicrypt.codegenerator.wizard.Configuration; -import de.cognicrypt.core.Constants; -import de.cognicrypt.utils.DeveloperProject; - -/** - * @author André Sonntag - */ -public class GenerationTest { - - /** - * In the following tests we check for the right number of methods in the appropriate classes. We choose this approach, because a comparing of the source code/bytes leads to - * problems when some changes happen in the XSLTemplate. - */ - - Logger log = Logger.getLogger(GenerationTest.class.getName()); - IJavaProject testJavaProject; - CodeGenerator generatorEnc; - CodeGenerator generatorSecPassword; - Task encTask; - Task secPasswordTask; - Configuration configEnc; - Configuration configSecPassword; - DeveloperProject developerProject; - static int counter = 0; - IResource targetFile; - - @After - public void tearDown() throws CoreException { - TestUtils.deleteProject(this.testJavaProject.getProject()); - } - - @Before - public void setUp() throws Exception { - GenerationTest.counter++; - this.testJavaProject = TestUtils.createJavaProject("TestProject_" + counter); - targetFile = TestUtils.generateJavaClassInJavaProject(this.testJavaProject, "testPackage", "Test"); - this.encTask = TestUtils.getTask("Encryption"); - this.generatorEnc = new CrySLBasedCodeGenerator(targetFile); - this.secPasswordTask = TestUtils.getTask("SecurePassword"); - this.generatorSecPassword = new CrySLBasedCodeGenerator(targetFile); - this.developerProject = this.generatorEnc.getDeveloperProject(); - } - - /** - * Test if the codegeneration for SymmetricEncrytion works, without any open class. - * @throws IOException - * @throws CoreException - */ - @Test - public void testCodeGeneration() throws CoreException, IOException { - this.configEnc = TestUtils.createCrySLConfiguration("encryption", targetFile, generatorEnc, developerProject); - final boolean encCheck = this.generatorEnc.generateCodeTemplates(this.configEnc, this.encTask.getAdditionalResources()); - assertTrue(encCheck); - } - - /** - * Test if the codegeneration for SymmetricEncrytion works with an open Test class. - */ - @Test - public void testCodeGenerationInTestClass() throws CoreException, IOException { - - final ICompilationUnit testClassUnit = TestUtils.getICompilationUnit(this.developerProject, "testPackage", "Test.java"); - TestUtils.openJavaFileInWorkspace(this.developerProject, "testPackage", testClassUnit); - - this.configEnc = TestUtils.createCrySLConfiguration("encryption", testClassUnit.getResource(), generatorEnc, this.developerProject); - this.generatorEnc.generateCodeTemplates(this.configEnc, this.encTask.getAdditionalResources()); - assertEquals(1, countMethods(testClassUnit)); - } - - /** - * Test if the Output class has the right methods, after the codegeneration runs two times (different tasks), without any open class. - */ - @Test - public void testCodeGenerationTwoTimesNoClassOpen() throws CoreException, IOException { - - this.configEnc = TestUtils.createCrySLConfiguration("encryption", targetFile, generatorEnc, this.developerProject); - this.generatorEnc.generateCodeTemplates(this.configEnc, this.encTask.getAdditionalResources()); - - this.configSecPassword = TestUtils.createCrySLConfiguration("securePassword", targetFile, generatorSecPassword, this.developerProject); - this.generatorSecPassword.generateCodeTemplates(this.configSecPassword, this.secPasswordTask.getAdditionalResources()); - - final ICompilationUnit outputUnit = TestUtils.getICompilationUnit(this.developerProject, Constants.PackageNameAsName, "Output.java"); - assertEquals(2, countMethods(outputUnit)); - } - - /** - * Test if the codegeneration puts the templageUsage-method in the open Enc class. - */ - // @Test - public void testCodeGenerationInEncClass() throws CoreException, IOException { - this.configEnc = TestUtils.createCrySLConfiguration("encryption", targetFile, generatorEnc, this.developerProject); - this.generatorEnc.generateCodeTemplates(this.configEnc, this.encTask.getAdditionalResources()); - final ICompilationUnit encUnit = TestUtils.getICompilationUnit(this.developerProject, Constants.PackageName, "Enc.java"); - TestUtils.openJavaFileInWorkspace(this.developerProject, Constants.PackageName, encUnit); - - this.configSecPassword = TestUtils.createCrySLConfiguration("securePassword", targetFile, generatorSecPassword, this.developerProject); - this.generatorSecPassword.generateCodeTemplates(this.configSecPassword, this.secPasswordTask.getAdditionalResources()); - - final ICompilationUnit outputUnit = TestUtils.getICompilationUnit(this.developerProject, Constants.PackageName, "Output.java"); - assertEquals(2, countMethods(outputUnit)); - } - - /** - * This method counts methods in ICompilationUnits - * - * @param unit - * @return - * @throws JavaModelException - */ - private int countMethods(final ICompilationUnit unit) throws JavaModelException { - return unit.getAllTypes()[0].getMethods().length; - } -} diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/QuestionsToTemplateTests.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/QuestionsToTemplateTests.java new file mode 100644 index 000000000..cc5f651f1 --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/QuestionsToTemplateTests.java @@ -0,0 +1,247 @@ +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import de.cognicrypt.codegenerator.question.Answer; +import de.cognicrypt.codegenerator.question.Question; +import de.cognicrypt.codegenerator.tasks.Task; +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.wizard.AltConfigWizard; + +import java.util.ArrayList; +import java.util.HashMap; + +/** + * The JUnit Plug-in tests check the correctness of CogniCrypt's code generation + * feature in determining the template path when the user chooses an arbitrary + * task and a set of given question-answers in the wizard dialog. This is + * important since the code generation depends on the computed path to generate + * the proper template for a given input from the user through CogniCrypt's + * wizard. + * + * @author Shahrzad Asghari + * @author Enri Ozuni + */ +public class QuestionsToTemplateTests { + + @Test + public void testEncryptionTaskWithEncryptedDigitalChannelAndByteArray() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted digital channel", "Byte Array"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedDigitalChannelAndFile() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted digital channel", "File"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionfiles"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedDigitalChannelAndString() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted digital channel", "String"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionstrings"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedDigitalChannelAndOther() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted digital channel", + "Other/Do not know"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedHardDriveAndByteArray() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted Hard Drive", "Byte Array"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedHardDriveAndFile() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted Hard Drive", "File"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionfiles"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedHardDriveAndString() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted Hard Drive", "String"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionstrings"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithEncryptedHardDriveAndOther() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Encrypted Hard Drive", "Other/Do not know"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedDigitalChannelAndByteArray() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Unencrypted digital channel (e.g. email)", + "Byte Array"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybrid"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedDigitalChannelAndFile() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Unencrypted digital channel (e.g. email)", + "File"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridfiles"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedDigitalChannelAndString() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Unencrypted digital channel (e.g. email)", + "String"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridstrings"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedDigitalChannelAndOther() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "Unencrypted digital channel (e.g. email)", + "Other/Do not know"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybrid"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedAnalogChannelAndByteArray() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", + "Unencrypted analog channel (e.g. phone, mail)", "Byte Array"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedAnalogChannelAndFile() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", + "Unencrypted analog channel (e.g. phone, mail)", "File"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionfiles"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedAnalogChannelAndString() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", + "Unencrypted analog channel (e.g. phone, mail)", "String"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionstrings"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithUnencryptedAnalogChannelAndOther() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", + "Unencrypted analog channel (e.g. phone, mail)", "Other/Do not know"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithNoSharingAndByteArray() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "No Sharing", "Byte Array"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithNoSharingAndFile() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "No Sharing", "File"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionfiles"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithNoSharingAndString() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "No Sharing", "String"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionstrings"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testEncryptionTaskWithNoSharingAndOther() { + AltConfigWizard wizard = new AltConfigWizard(); + wizard = constructTemplateForEncryptionTask(wizard, "Encryption", "No Sharing", "Other/Do not know"); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption"; + String actual = wizard.constructTemplateName(); + assertEquals(expected, actual); + } + + @Test + public void testSecurePasswordTask() { + AltConfigWizard wizard = new AltConfigWizard(); + Task securepassword = TestUtils.getTask("SecurePassword"); + wizard.setSelectedTask(securepassword); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/securepassword"; + assertEquals(expected, wizard.constructTemplateName()); + } + + @Test + public void testDigitalSignaturesTask() { + AltConfigWizard wizard = new AltConfigWizard(); + Task digitalsignatures = TestUtils.getTask("DigitalSignatures"); + wizard.setSelectedTask(digitalsignatures); + String expected = "src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures"; + assertEquals(expected, wizard.constructTemplateName()); + } + + private AltConfigWizard constructTemplateForEncryptionTask(AltConfigWizard wizard, String task, String firstAnswer, + String secondAnswer) { + Task encryptionTask = TestUtils.getTask(task); + wizard.setSelectedTask(encryptionTask); + ArrayList answers = new ArrayList(); + answers.add(firstAnswer); + answers.add(secondAnswer); + HashMap constraints = TestUtils.setConstraintsForTask(encryptionTask, answers); + wizard.addConstraints(constraints); + return wizard; + } +} \ No newline at end of file diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/SecurePasswordCodeGenTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/SecurePasswordCodeGenTest.java new file mode 100644 index 000000000..61112a957 --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/SecurePasswordCodeGenTest.java @@ -0,0 +1,64 @@ +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.logging.Logger; + +import org.eclipse.core.resources.IResource; +import org.eclipse.core.runtime.CoreException; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + +import de.cognicrypt.codegenerator.generator.CodeGenerator; +import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; +import de.cognicrypt.codegenerator.tasks.Task; +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.generator.test.Constants; +import de.cognicrypt.codegenerator.wizard.Configuration; +import de.cognicrypt.utils.DeveloperProject; + +/** + * @author Shahrzad Asghari + */ +public class SecurePasswordCodeGenTest { + + private Logger log = Logger.getLogger(SecurePasswordCodeGenTest.class.getName()); + private IJavaProject testJavaProject; + private CodeGenerator generatorSecPassword; + private Task secPasswordTask; + private Configuration configSecPassword; + private DeveloperProject developerProject; + private IResource targetFile; + + @After + public void tearDown() throws CoreException { + TestUtils.deleteProject(this.testJavaProject.getProject()); + } + + @Before + public void setUp() throws Exception { + this.testJavaProject = TestUtils.createJavaProject(Constants.PROJECT_NAME); + targetFile = TestUtils.generateJavaClassInJavaProject(this.testJavaProject, Constants.PACKAGE_NAME, + Constants.CLASS_NAME); + this.secPasswordTask = TestUtils.getTask("SecurePassword"); + this.generatorSecPassword = new CrySLBasedCodeGenerator(targetFile); + this.developerProject = this.generatorSecPassword.getDeveloperProject(); + } + + @Test + public void testCodeGenerationSecurePassword() throws CoreException, IOException { + final ICompilationUnit testClassUnit = TestUtils.getICompilationUnit(this.developerProject, + Constants.PACKAGE_NAME, Constants.JAVA_CLASS_NAME); + TestUtils.openJavaFileInWorkspace(this.developerProject, Constants.PACKAGE_NAME, testClassUnit); + + this.configSecPassword = TestUtils.createCrySLConfiguration("securepassword", testClassUnit.getResource(), + generatorSecPassword, this.developerProject); + final boolean encCheck = this.generatorSecPassword.generateCodeTemplates(this.configSecPassword, + this.secPasswordTask.getAdditionalResources()); + assertTrue(encCheck); + } +} \ No newline at end of file diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/TwoTimesCogniCryptRunTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/TwoTimesCogniCryptRunTest.java new file mode 100644 index 000000000..8ad5cebdb --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/TwoTimesCogniCryptRunTest.java @@ -0,0 +1,194 @@ +/******************************************************************************** + * Copyright (c) 2015-2019 TU Darmstadt, Paderborn University + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0 which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * SPDX-License-Identifier: EPL-2.0 + ********************************************************************************/ + +package de.cognicrypt.codegenerator.generator.test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.IJavaProject; +import org.junit.Test; + +import de.cognicrypt.codegenerator.generator.CodeGenerator; +import de.cognicrypt.codegenerator.generator.CrySLBasedCodeGenerator; +import de.cognicrypt.codegenerator.testutilities.TestUtils; +import de.cognicrypt.codegenerator.wizard.CrySLConfiguration; +import de.cognicrypt.core.Constants; +import de.cognicrypt.utils.DeveloperProject; + +/** + * @author Andre Sonntag + */ +public class TwoTimesCogniCryptRunTest { + + /** + * Scenario: User runs CogniCrypt two times without selecting a specific class + * or package. + * + * @throws Exception + */ + @Test + public void runCCTwoTimesNoSpecificSelection() throws Exception { + // task template + String templateSecEnc = "secretkeyencryption"; + String templateSecPwd = "securepassword"; + + // create Java project without any package or class + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject1"); + + // setup for code generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedProject.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(templateSecEnc, + generatedProject.getResource(), codeGenerator, developerProject); + + // first generation run + boolean secEncCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + assertTrue(secEncCheck); // check if code generation is successful for the first run + + // setup for second generation + chosenConfig = TestUtils.createCrySLConfiguration(templateSecPwd, generatedProject.getResource(), codeGenerator, + developerProject); + + // second generation run + boolean secPwdCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + assertTrue(secPwdCheck); // check if code generation is successful for the second run + + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + + ICompilationUnit pwdHasherClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "PasswordHasher.java"); + assertNotNull(pwdHasherClass); // check if PasswordHasher.java is created + + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); // check if Output.java is created + assertEquals(1, TestUtils.countMethods(outputClass)); + + TestUtils.deleteProject(generatedProject.getProject()); + } + + /** + * Scenario: User runs CogniCrypt two times and selects the previous generated + * output class. + * + * @throws Exception + */ + @Test + public void runCCTwoTimesOutputClassSelection() throws Exception { + // task template + String templateSecEnc = "secretkeyencryption"; + String templateSecPwd = "securepassword"; + + // create Java project without any package or class + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject2"); + + // setup for first generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedProject.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(templateSecEnc, + generatedProject.getResource(), codeGenerator, developerProject); + + // first generation run + boolean secEncCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + assertTrue(secEncCheck); // check if code generation is successful for the first run + + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); + + // setup for second generation + codeGenerator = new CrySLBasedCodeGenerator(outputClass.getResource()); + developerProject = codeGenerator.getDeveloperProject(); + chosenConfig = TestUtils.createCrySLConfiguration(templateSecPwd, outputClass.getResource(), codeGenerator, + developerProject); + + // second generation run + boolean secPwdCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + assertTrue(secPwdCheck); // check if code generation is successful for the second run + + ICompilationUnit pwdHasherClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "PasswordHasher.java"); + assertNotNull(pwdHasherClass); // check if PasswordHasher.java is created + + outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, "Output.java"); + assertNotNull(outputClass); + + int outputMethodCount = TestUtils.countMethods(outputClass); + assertEquals(1, outputMethodCount); + + TestUtils.deleteProject(generatedProject.getProject()); + } + + /** + * Scenario: User runs CogniCrypt two times and selects a previous generated + * "logic" class. + * + * @throws Exception + */ + @Test + public void runCCTwoTimesLogicClassSelection() throws Exception { + // task template + String templateSecEnc = "secretkeyencryption"; + String templateSecPwd = "securepassword"; + + // create Java project without any package or class + IJavaProject generatedProject = TestUtils.createJavaProject("TestProject3"); + + // setup for first generation + CodeGenerator codeGenerator = new CrySLBasedCodeGenerator(generatedProject.getResource()); + DeveloperProject developerProject = codeGenerator.getDeveloperProject(); + CrySLConfiguration chosenConfig = TestUtils.createCrySLConfiguration(templateSecEnc, + generatedProject.getResource(), codeGenerator, developerProject); + + // first generation run + boolean secEncCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + assertTrue(secEncCheck); // check if code generation is successful for the first run + + ICompilationUnit encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "SecureEncryptor.java"); + assertNotNull(encClass); // check if SecureEncryptor.java is created + + ICompilationUnit outputClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "Output.java"); + assertNotNull(outputClass); + + // setup for second generation + codeGenerator = new CrySLBasedCodeGenerator(encClass.getResource()); + developerProject = codeGenerator.getDeveloperProject(); + chosenConfig = TestUtils.createCrySLConfiguration(templateSecPwd, encClass.getResource(), codeGenerator, + developerProject); + + // second generation run + boolean secPwdCheck = codeGenerator.generateCodeTemplates(chosenConfig, ""); + assertTrue(secPwdCheck); // check if code generation is successful for the second run + + ICompilationUnit pwdHasherClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, + "PasswordHasher.java"); + assertNotNull(pwdHasherClass); // check if PasswordHasher.java is created + + encClass = TestUtils.getICompilationUnit(developerProject, Constants.PackageNameAsName, "SecureEncryptor.java"); + assertNotNull(encClass); + + int secureEncryptorMethodCount = TestUtils.countMethods(encClass); + + assertEquals(4, secureEncryptorMethodCount); + + TestUtils.deleteProject(generatedProject.getProject()); + } +} diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/DefaultTasksGeneratorTest.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/XSLCodeGenTest.java similarity index 78% rename from plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/DefaultTasksGeneratorTest.java rename to plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/XSLCodeGenTest.java index a07cf56a9..782cbbe7f 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/DefaultTasksGeneratorTest.java +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/generator/test/XSLCodeGenTest.java @@ -12,6 +12,8 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; + +import de.cognicrypt.codegenerator.Activator; import de.cognicrypt.codegenerator.generator.CodeGenerator; import de.cognicrypt.codegenerator.generator.XSLBasedGenerator; import de.cognicrypt.codegenerator.tasks.Task; @@ -22,9 +24,9 @@ /** * @author Andre Sonntag, Enri Ozuni */ -public class DefaultTasksGeneratorTest { +public class XSLCodeGenTest { - Logger log = Logger.getLogger(DefaultTasksGeneratorTest.class.getName()); + Logger log = Logger.getLogger(XSLCodeGenTest.class.getName()); IJavaProject testJavaProject; CodeGenerator generatorSECCOM; CodeGenerator generatorSecMPComp; @@ -36,10 +38,13 @@ public class DefaultTasksGeneratorTest { static int counter = 0; @Before - public void setUp() throws Exception { - - DefaultTasksGeneratorTest.counter++; - this.testJavaProject = TestUtils.createJavaProject("TestProject_" + counter); + public void setUp() { + XSLCodeGenTest.counter++; + try { + this.testJavaProject = TestUtils.createJavaProject("TestProject_" + counter); + } catch (CoreException e) { + Activator.getDefault().logError(e, "Failed to create test project."); + } this.SECCOMTask = TestUtils.getTask("SecureCommunication"); this.generatorSECCOM = new XSLBasedGenerator(this.testJavaProject.getProject(), this.SECCOMTask.getCodeTemplate()); @@ -51,8 +56,12 @@ public void setUp() throws Exception { } @After - public void tearDown() throws CoreException { - TestUtils.deleteProject(this.testJavaProject.getProject()); + public void tearDown() { + try { + TestUtils.deleteProject(this.testJavaProject.getProject()); + } catch (CoreException e) { + Activator.getDefault().logError(e, "Failed to delete test project."); + } } @Test diff --git a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/testutilities/TestUtils.java b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/testutilities/TestUtils.java index a392ede6d..e578b43fa 100644 --- a/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/testutilities/TestUtils.java +++ b/plugins/de.cognicrypt.codegenerator.tests/src/de/cognicrypt/codegenerator/testutilities/TestUtils.java @@ -1,11 +1,6 @@ /******************************************************************************** - * Copyright (c) 2015-2019 TU Darmstadt, Paderborn University - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v. 2.0 which is available at - * http://www.eclipse.org/legal/epl-2.0. - * - * SPDX-License-Identifier: EPL-2.0 + * Copyright (c) 2015-2019 TU Darmstadt, Paderborn University This program and the accompanying materials are made available under the terms of the Eclipse Public License v. 2.0 + * which is available at http://www.eclipse.org/legal/epl-2.0. SPDX-License-Identifier: EPL-2.0 ********************************************************************************/ package de.cognicrypt.codegenerator.testutilities; @@ -17,6 +12,7 @@ import java.nio.file.StandardCopyOption; import java.util.ArrayList; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.NoSuchElementException; import java.util.logging.Logger; @@ -57,6 +53,7 @@ import de.cognicrypt.codegenerator.wizard.Configuration; import de.cognicrypt.codegenerator.wizard.CrySLConfiguration; import de.cognicrypt.codegenerator.wizard.XSLConfiguration; +import de.cognicrypt.core.Activator; import de.cognicrypt.core.Constants; import de.cognicrypt.utils.DeveloperProject; import de.cognicrypt.utils.Utils; @@ -188,6 +185,35 @@ public static HashMap setDefaultConstraintsForTask(final Task return contraintsForTask; } + /** + * This method creates a HashMap. This HashMap contains the Questions and the associated given Answers for the selected Task. + * + * @param task Task + * @return An ArrayList containing answers for the selected task + */ + public static HashMap setConstraintsForTask(final Task task, ArrayList answers) { + final List pageList = (new QuestionsJSONReader()).getPages(task.getQuestionsJSONFile()); + final HashMap contraintsForTask = new LinkedHashMap<>(); + + if (pageList.isEmpty()) { + return contraintsForTask; + } + + for (Page page : pageList) { + for (int i = 0; i < page.getContent().size(); i++) { + Question tmpQuestion = page.getContent().get(i); + for (Answer answer : tmpQuestion.getAnswers()) { + if (answer.getValue().equals(answers.get(i))) { + contraintsForTask.put(tmpQuestion, answer); + break; + } + } + } + } + + return contraintsForTask; + } + /** * This method creates the necessary Configuration for a CodeGenerator. * @@ -255,22 +281,28 @@ public static void openJavaFileInWorkspace(final DeveloperProject project, final * @return IComplitationUnit * @throws CoreException */ - public static ICompilationUnit getICompilationUnit(final DeveloperProject project, final String packageName, final String cuName) throws CoreException, NoSuchElementException { + public static ICompilationUnit getICompilationUnit(final DeveloperProject project, final String packageName, final String cuName) throws CoreException { final IPackageFragment packageFragment = project.getPackagesOfProject(packageName); for (int i = 0; i < packageFragment.getCompilationUnits().length; i++) { if (packageFragment.getCompilationUnits()[i].getElementName().equals(cuName)) { + return packageFragment.getCompilationUnits()[i]; } } - throw new NoSuchElementException(); + return null; } - public static void printSourceCode(final DeveloperProject project, final String packageName) throws CoreException, NoSuchElementException { - final IPackageFragment packageFragment = project.getPackagesOfProject(packageName); - for (int i = 0; i < packageFragment.getCompilationUnits().length; i++) { - log.info("\n" + packageFragment.getCompilationUnits()[i].getSource()); + public static void printSourceCode(final DeveloperProject project, final String packageName) { + IPackageFragment packageFragment; + try { + packageFragment = project.getPackagesOfProject(packageName); + for (int i = 0; i < packageFragment.getCompilationUnits().length; i++) { + log.info("\n" + packageFragment.getCompilationUnits()[i].getSource()); + } + } + catch (CoreException e) { + Activator.getDefault().logError(e, Constants.ERROR_CANNOT_PRINT_SRC_CODE); } - } /** @@ -283,14 +315,16 @@ public static void printSourceCode(final DeveloperProject project, final String * @throws IOException * @throws CoreException */ - public static byte[] fileToByteArray(final DeveloperProject project, final String packageName, final ICompilationUnit cu) throws IOException, CoreException { - - final File f = new File(getFilePathInProject(project, packageName, cu)); - if (!(f.exists() && Files.isReadable(f.toPath()))) { - throw new IOException(); + public static byte[] fileToByteArray(final DeveloperProject project, final String packageName, final ICompilationUnit cu) { + File f; + try { + f = new File(getFilePathInProject(project, packageName, cu)); + return Files.readAllBytes(Paths.get(f.getPath())); } - - return Files.readAllBytes(Paths.get(f.getPath())); + catch (CoreException | IOException e) { + Activator.getDefault().logError(e, Constants.ERROR_CANNOT_FILE_TO_BYTEARRAY); + } + return null; } /** @@ -303,9 +337,8 @@ public static byte[] fileToByteArray(final DeveloperProject project, final Strin * @throws CoreException */ private static String getFilePathInProject(final DeveloperProject project, final String packageName, final ICompilationUnit cu) throws CoreException { - final String srcPath = project.getProjectPath() + Constants.innerFileSeparator + project.getSourcePath(); - final String cuPath = srcPath + Constants.innerFileSeparator + packageName + Constants.innerFileSeparator + cu.getElementName(); - return cuPath; + return project.getProjectPath() + Constants.innerFileSeparator + project.getSourcePath() + Constants.innerFileSeparator + packageName + Constants.innerFileSeparator + + cu.getElementName(); } /** @@ -329,4 +362,13 @@ public static int countStatements(ICompilationUnit unit, String method) throws J return -1; } + public static IPackageFragment generatePackageInJavaProject(IJavaProject generatedProject, String packageName) throws JavaModelException { + return generatedProject.getPackageFragmentRoot(generatedProject.getProject().getFolder("src")).createPackageFragment(packageName, false, null); + } + + public static boolean packageExists(IJavaProject generatedProject, String packagenameasname) { + final IPackageFragment expectedPackage = generatedProject.getPackageFragmentRoot(generatedProject.getProject().getFolder("src")).getPackageFragment(packagenameasname); + return expectedPackage != null; + } + } diff --git a/plugins/de.cognicrypt.codegenerator/plugin.xml b/plugins/de.cognicrypt.codegenerator/plugin.xml index 4b40cf177..63d790717 100644 --- a/plugins/de.cognicrypt.codegenerator/plugin.xml +++ b/plugins/de.cognicrypt.codegenerator/plugin.xml @@ -40,4 +40,19 @@ + + + + + + + diff --git a/plugins/de.cognicrypt.codegenerator/pom.xml b/plugins/de.cognicrypt.codegenerator/pom.xml index 02c94e052..89b452306 100644 --- a/plugins/de.cognicrypt.codegenerator/pom.xml +++ b/plugins/de.cognicrypt.codegenerator/pom.xml @@ -1,155 +1,155 @@ - - - 4.0.0 - de.cognicrypt.codegenerator - eclipse-plugin - - de.cognicrypt - de.cognicrypt.parent - 1.0.0-SNAPSHOT - ../../pom.xml - - - - - - org.eclipse.tycho - tycho-maven-plugin - ${tycho-version} - true - - - org.apache.maven.plugins - maven-surefire-plugin - 2.17 - - ../../shippable/testresults - - - - org.apache.maven.surefire - surefire-junit4 - 2.17 - - - junit - junit - 4.12 - - - - - - org.apache.maven.plugins - maven-compiler-plugin - 3.5.1 - - - junit - junit - 4.12 - - - - - compiletests - test-compile - - testCompile - - - ${project.basedir}\src\test\java\crossing\e1\featuremodel\clafer\test\* - 1.8 - 1.8 - - - - - - - - - - - org.eclipse.m2e - lifecycle-mapping - 1.0.0 - - - - - - org.eclipse.tycho - - tycho-packaging-plugin - - - [0.26.0,) - - - build-qualifier - validate-id - validate-version - - - - - - - - - org.eclipse.tycho - - tycho-compiler-plugin - - - [0.26.0,) - - - compile - - - - - - - - - org.apache.maven.plugins - maven-compiler-plugin - - [0.26.0,) - - - test-compile - - - - - - - - - org.apache.maven.plugins - maven-surefire-plugin - - [0.26.0,) - - - test - - - - - - - - - - - - - - de.cognicrypt - + + + 4.0.0 + de.cognicrypt.codegenerator + eclipse-plugin + + de.cognicrypt + de.cognicrypt.parent + 1.0.0-SNAPSHOT + ../../pom.xml + + + + + + org.eclipse.tycho + tycho-maven-plugin + ${tycho-version} + true + + + org.apache.maven.plugins + maven-surefire-plugin + 2.17 + + ../../shippable/testresults + + + + org.apache.maven.surefire + surefire-junit4 + 2.17 + + + junit + junit + 4.12 + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.5.1 + + + junit + junit + 4.12 + + + + + compiletests + test-compile + + testCompile + + + ${project.basedir}\src\test\java\crossing\e1\featuremodel\clafer\test\* + 1.8 + 1.8 + + + + + + + + + + + org.eclipse.m2e + lifecycle-mapping + 1.0.0 + + + + + + org.eclipse.tycho + + tycho-packaging-plugin + + + [0.26.0,) + + + build-qualifier + validate-id + validate-version + + + + + + + + + org.eclipse.tycho + + tycho-compiler-plugin + + + [0.26.0,) + + + compile + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + [0.26.0,) + + + test-compile + + + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + + [0.26.0,) + + + test + + + + + + + + + + + + + + de.cognicrypt + diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures/Signer.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures/SecureSigner.java similarity index 75% rename from plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures/Signer.java rename to plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures/SecureSigner.java index 8c0a525d7..bbf83a851 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures/Signer.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/digitalsignatures/SecureSigner.java @@ -14,10 +14,11 @@ import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.SignatureException; +import java.util.Base64; import de.cognicrypt.codegenerator.crysl.CrySLCodeGenerator; -public class Signer { +public class SecureSigner { public static java.security.KeyPair getKey() throws NoSuchAlgorithmException { java.security.KeyPair pair = null; @@ -25,17 +26,17 @@ public static java.security.KeyPair getKey() throws NoSuchAlgorithmException { return pair; } - public static byte[] sign(String msg, java.security.KeyPair keyPair) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { + public static java.lang.String sign(java.lang.String msg, java.security.KeyPair keyPair) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { byte[] msgBytes = msg.getBytes(StandardCharsets.UTF_8); byte[] res = null; java.security.PrivateKey privKey = keyPair.getPrivate(); CrySLCodeGenerator.getInstance().includeClass("java.security.Signature").addParameter(privKey, "priv").addParameter(msgBytes, "inpba").addReturnObject(res).generate(); - return res; + return Base64.getEncoder().encodeToString(res); } - public static boolean vfy(String msg, java.security.KeyPair keyPair) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { + public static boolean vfy(java.lang.String msg, java.security.KeyPair keyPair) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException { boolean res = false; - byte[] msgBytes = msg.getBytes(StandardCharsets.UTF_8); + byte[] msgBytes = Base64.getDecoder().decode(msg); java.security.PublicKey pubKey = keyPair.getPublic(); CrySLCodeGenerator.getInstance().includeClass("java.security.Signature").addParameter(pubKey, "pub").addParameter(msgBytes, "sign").addReturnObject(res).generate(); return res; diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption/SecureEncryptor.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption/SecureEncryptor.java index 0dec32cd7..631bf4c38 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption/SecureEncryptor.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryption/SecureEncryptor.java @@ -52,7 +52,7 @@ public byte[] decrypt(byte[] ciphertext, javax.crypto.SecretKey key) { int mode = Cipher.DECRYPT_MODE; byte[] res = null; CrySLCodeGenerator.getInstance().includeClass("javax.crypto.spec.IvParameterSpec").addParameter(ivBytes, "iv").includeClass("javax.crypto.Cipher") - .addParameter(mode, "encmode").addParameter(data, "palinText").addParameter(key, "key").addReturnObject(res).generate(); + .addParameter(mode, "encmode").addParameter(key, "key").addParameter(data, "plainText").addReturnObject(res).generate(); return res; } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybrid/SecureEncryptor.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybrid/SecureEncryptor.java index 7baede503..119d22419 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybrid/SecureEncryptor.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybrid/SecureEncryptor.java @@ -41,7 +41,7 @@ public byte[] encryptSessionKey(javax.crypto.SecretKey sessionKey, java.security } public byte[] encryptData(byte[] plaintext, javax.crypto.SecretKey key) { - byte[] ivBytes = new byte[32]; + byte[] ivBytes = new byte[16]; byte[] cipherText = null; int mode = Cipher.ENCRYPT_MODE; @@ -57,11 +57,11 @@ public byte[] encryptData(byte[] plaintext, javax.crypto.SecretKey key) { public byte[] decryptData(byte[] ciphertext, javax.crypto.SecretKey key) { - byte[] ivBytes = new byte[32]; + byte[] ivBytes = new byte[16]; byte[] data = new byte[ciphertext.length - ivBytes.length]; - System.arraycopy(data, 0, ivBytes, 0, ivBytes.length); - System.arraycopy(data, ivBytes.length, data, 0, data.length); - + System.arraycopy(ciphertext, 0, ivBytes, 0, ivBytes.length); + System.arraycopy(ciphertext, ivBytes.length, data, 0, data.length); + int mode = Cipher.DECRYPT_MODE; byte[] res = null; CrySLCodeGenerator.getInstance().includeClass("javax.crypto.spec.IvParameterSpec").addParameter(ivBytes, "iv").includeClass("javax.crypto.Cipher") diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridfiles/SecureEncryptor.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridfiles/SecureEncryptor.java index 9ee720362..b734a6f61 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridfiles/SecureEncryptor.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridfiles/SecureEncryptor.java @@ -64,9 +64,9 @@ public java.io.File decryptData(java.io.File ciphertext, javax.crypto.SecretKey byte[] ciphertextFile = Files.readAllBytes(Paths.get(ciphertext.getAbsolutePath())); byte[] ivBytes = new byte[key.getEncoded().length]; byte[] data = new byte[ciphertextFile.length - ivBytes.length]; - System.arraycopy(data, 0, ivBytes, 0, ivBytes.length); - System.arraycopy(data, ivBytes.length, data, 0, data.length); - + System.arraycopy(ciphertextFile, 0, ivBytes, 0, ivBytes.length); + System.arraycopy(ciphertextFile, ivBytes.length, data, 0, data.length); + int mode = Cipher.DECRYPT_MODE; byte[] res = null; CrySLCodeGenerator.getInstance().includeClass("javax.crypto.spec.IvParameterSpec").addParameter(ivBytes, "iv").includeClass("javax.crypto.Cipher") diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridstrings/SecureEncryptor.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridstrings/SecureEncryptor.java index 907e8f16e..d689de8af 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridstrings/SecureEncryptor.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/encryptionhybridstrings/SecureEncryptor.java @@ -15,6 +15,7 @@ import java.nio.file.Paths; import java.security.GeneralSecurityException; import java.security.NoSuchAlgorithmException; +import java.util.Base64; import javax.crypto.Cipher; @@ -43,37 +44,35 @@ public byte[] encryptSessionKey(javax.crypto.SecretKey sessionKey, java.security return wrappedKeyBytes; } - public java.io.File encryptData(java.io.File plaintext, javax.crypto.SecretKey key) throws IOException { - byte[] ivBytes = new byte[32]; + public java.lang.String encryptData(java.lang.String plaintext, javax.crypto.SecretKey key) throws IOException { + byte[] ivBytes = new byte[16]; byte[] cipherText = null; - byte[] plaintextFile = Files.readAllBytes(Paths.get(plaintext.getAbsolutePath())); + byte[] plaintextString = plaintext.getBytes("UTF-8"); int mode = Cipher.ENCRYPT_MODE; CrySLCodeGenerator.getInstance().includeClass("java.security.SecureRandom").addParameter(ivBytes, "next").includeClass("javax.crypto.spec.IvParameterSpec") - .addParameter(ivBytes, "iv").includeClass("javax.crypto.Cipher").addParameter(mode, "encmode").addParameter(plaintextFile, "plainText").addParameter(key, "key") + .addParameter(ivBytes, "iv").includeClass("javax.crypto.Cipher").addParameter(mode, "encmode").addParameter(plaintextString, "plainText").addParameter(key, "key") .addReturnObject(cipherText).generate(); byte[] ret = new byte[ivBytes.length + cipherText.length]; System.arraycopy(ivBytes, 0, ret, 0, ivBytes.length); System.arraycopy(cipherText, 0, ret, ivBytes.length, cipherText.length); - Files.write(Paths.get(plaintext.getAbsolutePath()), ret); - return plaintext; + return Base64.getEncoder().encodeToString(ret); + } - public java.io.File decryptData(java.io.File ciphertext, javax.crypto.SecretKey key) throws IOException { - byte[] ciphertextFile = Files.readAllBytes(Paths.get(ciphertext.getAbsolutePath())); - byte[] ivBytes = new byte[32]; - byte[] data = new byte[ciphertextFile.length - ivBytes.length]; - System.arraycopy(data, 0, ivBytes, 0, ivBytes.length); - System.arraycopy(data, ivBytes.length, data, 0, data.length); + public java.lang.String decryptData(java.lang.String ciphertext, javax.crypto.SecretKey key) throws IOException { + byte[] ciphertextString = Base64.getDecoder().decode(ciphertext); + byte[] ivBytes = new byte[16]; + byte[] data = new byte[ciphertextString.length - ivBytes.length]; + System.arraycopy(ciphertextString, 0, ivBytes, 0, ivBytes.length); + System.arraycopy(ciphertextString, ivBytes.length, data, 0, data.length); int mode = Cipher.DECRYPT_MODE; byte[] res = null; CrySLCodeGenerator.getInstance().includeClass("javax.crypto.spec.IvParameterSpec").addParameter(ivBytes, "iv").includeClass("javax.crypto.Cipher") .addParameter(mode, "encmode").addParameter(data, "plainText").addParameter(key, "key").addReturnObject(res).generate(); - - Files.write(Paths.get(ciphertext.getAbsolutePath()), res); - return ciphertext; + return new String(res, "UTF-8"); } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/securepassword/PasswordHasher.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/securepassword/PasswordHasher.java index 5bfb65400..5a6cc23d9 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/securepassword/PasswordHasher.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/securepassword/PasswordHasher.java @@ -21,20 +21,22 @@ public class PasswordHasher { public static java.lang.String createPWHash(char[] pwd) throws GeneralSecurityException { byte[] salt = new byte[32]; byte[] pwdHashBytes = null; + int keysize = 160; CrySLCodeGenerator.getInstance().includeClass("java.security.SecureRandom").addParameter(salt, "next").includeClass("java.security.PBEKeySpec") - .addParameter(pwd, "password").includeClass("javax.crypto.SecretKeyFactory").includeClass("java.security.SecretKey").addReturnObject(pwdHashBytes).generate(); + .addParameter(pwd, "password").addParameter(salt, "salt").addParameter(keysize, "keylength").includeClass("javax.crypto.SecretKeyFactory").includeClass("java.security.SecretKey").addReturnObject(pwdHashBytes).generate(); - String pwdHash = toBase64(salt) + ":" + toBase64(pwdHashBytes); + java.lang.String pwdHash = toBase64(salt) + ":" + toBase64(pwdHashBytes); return pwdHash; } public static boolean verifyPWHash(char[] pwd, java.lang.String pwdhash) throws GeneralSecurityException { - String[] parts = pwdhash.split(":"); + java.lang.String[] parts = pwdhash.split(":"); byte[] salt = fromBase64(parts[0]); byte[] res = null; + int keysize = 160; - CrySLCodeGenerator.getInstance().includeClass("java.security.PBEKeySpec").addParameter(salt, "salt").addParameter(pwd, "passowrd") + CrySLCodeGenerator.getInstance().includeClass("java.security.PBEKeySpec").addParameter(pwd, "password").addParameter(salt, "salt").addParameter(keysize, "keylength") .includeClass("javax.crypto.SecretKeyFactory").includeClass("java.security.SecretKey").addReturnObject(res).generate(); Boolean areEqual = slowEquals(res, fromBase64(parts[1])); @@ -49,11 +51,11 @@ private static boolean slowEquals(byte[] a, byte[] b) { return diff == 0; } - private static String toBase64(byte[] array) { + private static java.lang.String toBase64(byte[] array) { return DatatypeConverter.printBase64Binary(array); } - private static byte[] fromBase64(String hash) { + private static byte[] fromBase64(java.lang.String hash) { return DatatypeConverter.parseBase64Binary(hash); } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/stringhashing/StringHasher.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/stringhashing/StringHasher.java index b7dfb16e4..d5bd2bdec 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/stringhashing/StringHasher.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/crysl/templates/stringhashing/StringHasher.java @@ -18,18 +18,18 @@ public class StringHasher { - public static java.lang.String createHash(String msg) throws GeneralSecurityException { + public static java.lang.String createHash(java.lang.String msg) throws GeneralSecurityException { byte[] plainBytes = msg.getBytes(StandardCharsets.UTF_8); byte[] out = null; CrySLCodeGenerator.getInstance().includeClass("java.security.MessageDigest").addReturnObject(out).generate(); return Base64.getEncoder().encodeToString(out); } - public static boolean verifyHash(java.lang.String newMsg, java.lang.String compareeHash) { + public static boolean verifyHash(java.lang.String compareeHash, java.lang.String newMsg) { byte[] plainBytes = newMsg.getBytes(StandardCharsets.UTF_8); byte[] out = null; CrySLCodeGenerator.getInstance().includeClass("java.security.MessageDigest").addReturnObject(out).generate(); - return Base64.getEncoder().encodeToString(out).equals(newMsg); + return Base64.getEncoder().encodeToString(out).equals(compareeHash); } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/ClaferModel.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/ClaferModel.java index ed8553cde..72e2f7161 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/ClaferModel.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/ClaferModel.java @@ -23,6 +23,7 @@ import org.clafer.scope.Scope; import de.cognicrypt.codegenerator.Activator; +import de.cognicrypt.core.Constants; /** * This class handles the clafer model on the file-system level. @@ -84,7 +85,7 @@ private void loadModel(final File file) { setEnumList(astModel); } catch (final IOException e) { - Activator.getDefault().logError(e); + Activator.getDefault().logError(e, Constants.ERROR_MESSAGE_NO_FILE); } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/InstanceGenerator.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/InstanceGenerator.java index f2be148ed..8072e796b 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/InstanceGenerator.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/featuremodel/clafer/InstanceGenerator.java @@ -119,6 +119,7 @@ private void addConstraints(final AstClafer taskAlgorithm, final List> separatedCombinations = new ArrayList<>(); @@ -330,7 +331,7 @@ public List generateInstances(final HashMap qu } } catch (final Exception e) { - Activator.getDefault().logError(e); + Activator.getDefault().logError(e, "Error occured when generating Clafer instances."); } this.generatedInstances = new ArrayList<>(this.uniqueInstances.values()); generateInstanceMapping(); diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLObject.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLObject.java index 0799286b4..eb33bea3c 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLObject.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLObject.java @@ -10,10 +10,14 @@ package de.cognicrypt.codegenerator.generator; -import crypto.rules.CryptSLObject; +import crypto.rules.CrySLObject; -public class CodeGenCrySLObject extends CryptSLObject { +public class CodeGenCrySLObject extends CrySLObject { + /** + * + */ + private static final long serialVersionUID = 7651301776757536370L; private final String crySLVariable; private String method = ""; private int pos = -1; @@ -23,7 +27,7 @@ public CodeGenCrySLObject(String name, String type, String crySLVariable) { this.crySLVariable = crySLVariable; } - public CodeGenCrySLObject(CryptSLObject obj, String crySLVariable) { + public CodeGenCrySLObject(CrySLObject obj, String crySLVariable) { this(obj.getVarName(), obj.getJavaType(), crySLVariable); } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLRule.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLRule.java index 9eccd11d2..537a3f819 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLRule.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenCrySLRule.java @@ -15,27 +15,27 @@ import java.util.Map.Entry; import crypto.interfaces.ISLConstraint; -import crypto.rules.CryptSLForbiddenMethod; -import crypto.rules.CryptSLMethod; -import crypto.rules.CryptSLObject; -import crypto.rules.CryptSLPredicate; -import crypto.rules.CryptSLRule; +import crypto.rules.CrySLForbiddenMethod; +import crypto.rules.CrySLMethod; +import crypto.rules.CrySLObject; +import crypto.rules.CrySLPredicate; +import crypto.rules.CrySLRule; import crypto.rules.StateMachineGraph; -public class CodeGenCrySLRule extends CryptSLRule { +public class CodeGenCrySLRule extends CrySLRule { private static final long serialVersionUID = -7488186084564628280L; - private List requiredMethods; + private List requiredMethods; private List requiredPars; - private CryptSLObject requiredRetObj; + private CrySLObject requiredRetObj; - public CodeGenCrySLRule(String _className, List> defObjects, List _forbiddenMethods, StateMachineGraph _usagePattern, List _constraints, List _predicates, List pars, CryptSLObject reqRet) { + public CodeGenCrySLRule(String _className, List> defObjects, List _forbiddenMethods, StateMachineGraph _usagePattern, List _constraints, List _predicates, List pars, CrySLObject reqRet) { super(_className, defObjects, _forbiddenMethods, _usagePattern, _constraints, _predicates); requiredPars = pars; requiredRetObj = reqRet; } - public CodeGenCrySLRule(CryptSLRule rule, List pars, CryptSLObject reqRet) { + public CodeGenCrySLRule(CrySLRule rule, List pars, CrySLObject reqRet) { this(rule.getClassName(), rule.getObjects(), rule.getForbiddenMethods(), rule.getUsagePattern(), rule.getConstraints(), rule.getPredicates(), pars, reqRet); } @@ -43,13 +43,13 @@ public boolean addConstraint(ISLConstraint constraint) { return constraints.add(constraint); } - public boolean addForbiddenMethod(CryptSLMethod method) { - return forbiddenMethods.add(new CryptSLForbiddenMethod(method, false)); + public boolean addForbiddenMethod(CrySLMethod method) { + return forbiddenMethods.add(new CrySLForbiddenMethod(method, false)); } - public boolean addRequiredMethod(CryptSLMethod method) { + public boolean addRequiredMethod(CrySLMethod method) { if (requiredMethods == null) { - requiredMethods = new ArrayList(); + requiredMethods = new ArrayList(); } return requiredMethods.add(method); } @@ -58,7 +58,7 @@ public List getRequiredPars() { return requiredPars; } - public CryptSLObject getRequiredRetObj() { + public CrySLObject getRequiredRetObj() { return requiredRetObj; } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenerator.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenerator.java index 16041f1f9..56c8aba2b 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenerator.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeGenerator.java @@ -51,7 +51,7 @@ import de.cognicrypt.core.Constants; import de.cognicrypt.utils.ComparableEntry; import de.cognicrypt.utils.DeveloperProject; -import de.cognicrypt.utils.Utils; +import de.cognicrypt.utils.UIUtils; public abstract class CodeGenerator { @@ -61,7 +61,6 @@ public abstract class CodeGenerator { private int endPosForImports = -1; private int startingPositionForRunMethod = -1; private int startPosForImports = -1; - private String temporaryOutputFile; protected CodeGenerator(final IResource target) { this.project = new DeveloperProject(target.getProject()); @@ -109,20 +108,23 @@ public DeveloperProject getDeveloperProject() { */ protected boolean insertCallCodeIntoFile(final String temporaryOutputFile, final boolean openFileFlag, final boolean authorFlag, final boolean tempFlag) throws BadLocationException, CoreException, IOException { if (this.targetFile != null) { - IDE.openEditor(Utils.getCurrentlyOpenPage(), targetFile); + if (this.targetFile.getRawLocation().toOSString().equals(Paths.get(temporaryOutputFile).toString())) { + return true; + } else { + IDE.openEditor(UIUtils.getCurrentlyOpenPage(), targetFile); + } } if ((openFileFlag && authorFlag) || !openFileFlag) { final StringBuilder sb = new StringBuilder(temporaryOutputFile); sb.delete(temporaryOutputFile.length() - 9, temporaryOutputFile.length() - 5); final IFile output = tempFlag == true ? this.project.getIFile(sb.toString()) : this.project.getIFile(temporaryOutputFile); - IDE.openEditor(Utils.getCurrentlyOpenPage(), output); + IDE.openEditor(UIUtils.getCurrentlyOpenPage(), output); } - final IEditorPart currentlyOpenPart = Utils.getCurrentlyOpenEditor(); + final IEditorPart currentlyOpenPart = UIUtils.getCurrentlyOpenEditor(); if (currentlyOpenPart == null || !(currentlyOpenPart instanceof AbstractTextEditor)) { - Activator.getDefault().logError(null, - "Could not open access the editor of the file. Therefore, an outputfile containing calls to the generated classes in the Crypto package was generated."); + Activator.getDefault().logError("Could not open access the editor of the file. Therefore, an outputfile containing calls to the generated classes in the Crypto package was generated."); return false; } @@ -132,7 +134,7 @@ protected boolean insertCallCodeIntoFile(final String temporaryOutputFile, final final TreeSet> methLims = new TreeSet<>(); final SimpleEntry> classlims = new SimpleEntry<>(0, null); - final ASTParser astp = ASTParser.newParser(AST.JLS10); + final ASTParser astp = ASTParser.newParser(AST.JLS11); astp.setSource(docContent.toCharArray()); astp.setKind(ASTParser.K_COMPILATION_UNIT); final CompilationUnit cu = (CompilationUnit) astp.createAST(null); @@ -170,7 +172,7 @@ public boolean visit(final TypeDeclaration node) { } } - final int imports = docContent.startsWith("package") ? docContent.indexOf(Constants.lineSeparator) : 0; + final int imports = docContent.startsWith("package") ? docContent.indexOf("\n") : 0; final String[] callsForGenClasses = getCallsForGenClasses(temporaryOutputFile); currentlyOpenDocument.replace(cursorPos, 0, callsForGenClasses[1]); currentlyOpenDocument.replace(imports, 0, callsForGenClasses[0] + Constants.lineSeparator); @@ -192,13 +194,13 @@ private String[] getCallsForGenClasses(final String filePath) throws IOException // Checks whether file exists final File f = new File(filePath); if (!(f.exists() && Files.isWritable(f.toPath()))) { - Activator.getDefault().logError(null, Constants.NoTemporaryOutputFile); + Activator.getDefault().logError(Constants.NoTemporaryOutputFile); return null; } // Retrieve complete content from file final String fileContent = String.join(Constants.lineSeparator, Files.readAllLines(Paths.get(filePath))); // Determine start and end position for relevant extract - final ASTParser astp = ASTParser.newParser(AST.JLS10); + final ASTParser astp = ASTParser.newParser(AST.JLS11); astp.setSource(fileContent.toCharArray()); astp.setKind(ASTParser.K_COMPILATION_UNIT); final CompilationUnit cu = (CompilationUnit) astp.createAST(null); @@ -327,11 +329,11 @@ protected void cleanUpProject(IEditorPart editor) throws CoreException { final ICompilationUnit[] generatedCUnits = this.project.getPackagesOfProject(Constants.PackageNameAsName).getCompilationUnits(); boolean anyFileOpen = false; - if(editor == null && generatedCUnits[0].getResource().getType() == IResource.FILE) { - IFile genClass = (IFile) generatedCUnits[0].getResource(); - IDE.openEditor(Utils.getCurrentlyOpenPage(), genClass); - editor = Utils.getCurrentlyOpenPage().getActiveEditor(); - anyFileOpen = true; + if (editor == null && generatedCUnits[0].getResource().getType() == IResource.FILE) { + IFile genClass = (IFile) generatedCUnits[0].getResource(); + IDE.openEditor(UIUtils.getCurrentlyOpenPage(), genClass); + editor = UIUtils.getCurrentlyOpenPage().getActiveEditor(); + anyFileOpen = true; } final OrganizeImportsAction organizeImportsActionForAllFilesTouchedDuringGeneration = new OrganizeImportsAction(editor.getSite()); @@ -340,10 +342,10 @@ protected void cleanUpProject(IEditorPart editor) throws CoreException { organizeImportsActionForAllFilesTouchedDuringGeneration.runOnMultiple(generatedCUnits); if (anyFileOpen) { - Utils.closeEditor(editor); + UIUtils.closeEditor(editor); } - - final ICompilationUnit openClass = JavaCore.createCompilationUnitFrom(Utils.getCurrentlyOpenFile(editor)); + + final ICompilationUnit openClass = JavaCore.createCompilationUnitFrom(UIUtils.getCurrentlyOpenFile(editor)); organizeImportsActionForAllFilesTouchedDuringGeneration.run(openClass); faa.runOnMultiple(new ICompilationUnit[] { openClass }); editor.doSave(null); diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeHandler.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeHandler.java index daf828c46..59d86242e 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeHandler.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CodeHandler.java @@ -76,7 +76,7 @@ public File writeToDisk(final String folderPath) throws Exception { * @throws CompilationFailedException * If the compilation process was not successful an exception is thrown. */ - public List compile() throws CompilationFailedException, RuntimeException, IllegalStateException { + public List compile() throws CompilationFailedException { // setup compiler // JavaCompiler compiler = new EclipseCompiler(); // StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); @@ -164,7 +164,7 @@ public boolean run(String clazz, String method, Class[] parameterTypes, Objec try { loadedClass.getMethod(method, parameterTypes).invoke(loadedClass.newInstance(), args); } catch (Exception e) { - Activator.getDefault().logError(e, "Exception is occured during method execution."); + Activator.getDefault().logError(e, "Exception occured during method execution."); return false; } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLBasedCodeGenerator.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLBasedCodeGenerator.java index e9cda78b2..3c48a13d1 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLBasedCodeGenerator.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLBasedCodeGenerator.java @@ -41,7 +41,9 @@ import org.eclipse.jdt.core.dom.ASTNode; import org.eclipse.jdt.core.dom.ASTParser; import org.eclipse.jdt.core.dom.ASTVisitor; +import org.eclipse.jdt.core.dom.Block; import org.eclipse.jdt.core.dom.CompilationUnit; +import org.eclipse.jdt.core.dom.ExpressionStatement; import org.eclipse.jdt.core.dom.ImportDeclaration; import org.eclipse.jdt.core.dom.MethodDeclaration; import org.eclipse.jdt.core.dom.MethodInvocation; @@ -56,17 +58,17 @@ import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.PlatformUI; -import crypto.interfaces.ICryptSLPredicateParameter; +import crypto.interfaces.ICrySLPredicateParameter; import crypto.interfaces.ISLConstraint; -import crypto.rules.CryptSLComparisonConstraint; -import crypto.rules.CryptSLCondPredicate; -import crypto.rules.CryptSLConstraint; -import crypto.rules.CryptSLConstraint.LogOps; -import crypto.rules.CryptSLMethod; -import crypto.rules.CryptSLObject; -import crypto.rules.CryptSLPredicate; -import crypto.rules.CryptSLRule; -import crypto.rules.CryptSLValueConstraint; +import crypto.rules.CrySLComparisonConstraint; +import crypto.rules.CrySLCondPredicate; +import crypto.rules.CrySLConstraint; +import crypto.rules.CrySLConstraint.LogOps; +import crypto.rules.CrySLMethod; +import crypto.rules.CrySLObject; +import crypto.rules.CrySLPredicate; +import crypto.rules.CrySLRule; +import crypto.rules.CrySLValueConstraint; import crypto.rules.StateMachineGraph; import crypto.rules.StateNode; import crypto.rules.TransitionEdge; @@ -74,6 +76,7 @@ import de.cognicrypt.codegenerator.wizard.Configuration; import de.cognicrypt.codegenerator.wizard.CrySLConfiguration; import de.cognicrypt.core.Constants; +import de.cognicrypt.utils.CrySLUtils; import de.cognicrypt.utils.Utils; /** @@ -103,8 +106,8 @@ private static void clearRuleParameterCache() { private List kills = new ArrayList(); - List>> predicateConnections; - Entry> toBeEnsuredPred = null; + List>> predicateConnections; + Entry> toBeEnsuredPred = null; CodeGenCrySLRule curRule = null; @@ -126,19 +129,19 @@ public List getKills() { return kills; } - public List>> getPredicateConnections() { + public List>> getPredicateConnections() { return predicateConnections; } - public void setPredicateConnections(List>> predicateConnections) { + public void setPredicateConnections(List>> predicateConnections) { this.predicateConnections = predicateConnections; } - public Entry> getToBeEnsuredPred() { + public Entry> getToBeEnsuredPred() { return toBeEnsuredPred; } - public void setToBeEnsuredPred(Entry> toBeEnsuredPred) { + public void setToBeEnsuredPred(Entry> toBeEnsuredPred) { this.toBeEnsuredPred = toBeEnsuredPred; } @@ -157,10 +160,10 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo genFolder = this.project.getProjectPath() + Constants.innerFileSeparator + this.project .getSourcePath() + Constants.CodeGenerationCallFolder + Constants.innerFileSeparator; } catch (CoreException e1) { - Activator.getDefault().logError(e1); + Activator.getDefault().logError(e1, Constants.CodeGenerationErrorMessage); } Set generatedClasses = new HashSet(); - Map> reliablePreds = new HashMap>(); + Map> reliablePreds = new HashMap>(); Map> tmpUsagePars = new HashMap>(); GeneratorClass templateClass = new GeneratorClass(); @@ -177,7 +180,7 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo tmplUsage.setReturnType("void"); tmplUsage.setName(Constants.NameOfTemporaryMethod); - RuleDependencyTree rdt = new RuleDependencyTree(Utils.readCrySLRules()); + RuleDependencyTree rdt = new RuleDependencyTree(CrySLUtils.readCrySLRules()); for (GeneratorMethod method : ruleClass.getMethods()) { tmpUsagePars.put(method.getName(), new ArrayList()); @@ -186,14 +189,14 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo continue; } String usedClass = rules.get(rules.size() - 1).getClassName(); - predicateConnections = new ArrayList>>(); + predicateConnections = new ArrayList>>(); for (int i = 0; i < rules.size(); i++) { // analyseConstraints(rules.get(i).getConstraints()); if (i < rules.size() - 1) { - CryptSLRule nextRule = rules.get(i + 1); - CryptSLRule curRule = rules.get(i); + CrySLRule nextRule = rules.get(i + 1); + CrySLRule curRule = rules.get(i); if (rdt.hasDirectPath(curRule, nextRule)) { populatePredicateConnections(curRule, nextRule); @@ -217,9 +220,9 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo clearRuleParameterCache(); boolean next = true; boolean lastRule = rules.get(rules.size() - 1).equals(rule); - // get state machine of cryptsl rule + // get state machine of crysl rule StateMachineGraph stateMachine = rule.getUsagePattern(); - Optional>> toBeEnsured = determineEnsurePredicates(rule, lastRule); + Optional>> toBeEnsured = determineEnsurePredicates(rule, lastRule); Iterator> transitions = getTransitionsFromStateMachine(stateMachine); @@ -233,7 +236,7 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo imports.addAll(Arrays.asList(Constants.xmlimportsarr)); ruleClass.addImports(imports); - Map> mayUsePreds = determineMayUsePreds(usedClass); + Map> mayUsePreds = determineMayUsePreds(usedClass); ArrayList methodInvocations = generateMethodInvocations(rule, method, currentTransitions, mayUsePreds, imports, lastRule); if (methodInvocations.isEmpty()) { @@ -242,7 +245,7 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo if (toBeEnsuredPred != null && toBeEnsured.isPresent() && !toBeEnsured.get().getKey().getParameters().get(0) .equals(toBeEnsuredPred.getKey().getParameters().get(0))) { - Entry> originalPred = toBeEnsured.get(); + Entry> originalPred = toBeEnsured.get(); int indexOf = predicateConnections.indexOf(originalPred); predicateConnections.remove(indexOf); predicateConnections.add(indexOf, toBeEnsuredPred); @@ -293,7 +296,7 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo codeHandler.writeToDisk(genFolder); cleanUpProject(page.getActiveEditor()); } catch (Exception e) { - Activator.getDefault().logError(e); + Activator.getDefault().logError(e, Constants.CodeGenerationErrorMessage); } try { @@ -301,35 +304,35 @@ public boolean generateCodeTemplates(Configuration chosenConfig, String pathToFo false); removeCryptoPackageIfEmpty(); } catch (CoreException | BadLocationException | IOException e) { - Activator.getDefault().logError(e); + Activator.getDefault().logError(e, Constants.CodeGenerationErrorMessage); } return generatedClasses != null; } - public void populatePredicateConnections(CryptSLRule curRule, CryptSLRule nextRule) { + public void populatePredicateConnections(CrySLRule curRule, CrySLRule nextRule) { boolean now = false; - for (CryptSLPredicate ensPred : curRule.getPredicates()) { + for (CrySLPredicate ensPred : curRule.getPredicates()) { String nextType = nextRule.getClassName(); - String predType = ((CryptSLObject) ensPred.getParameters().get(0)).getJavaType(); + String predType = ((CrySLObject) ensPred.getParameters().get(0)).getJavaType(); if (Utils.isSubType(nextType, predType) || Utils.isSubType(predType, nextType)) { - predicateConnections.add(new SimpleEntry<>(ensPred, new SimpleEntry(curRule, nextRule))); + predicateConnections.add(new SimpleEntry<>(ensPred, new SimpleEntry(curRule, nextRule))); now = true; } - for (CryptSLPredicate reqPred : nextRule.getRequiredPredicates()) { - if (reqPred.equals(ensPred) && Utils.isSubType(((CryptSLObject) reqPred.getParameters().get(0)).getJavaType(), predType)) { - Optional>> matchedPred = predicateConnections.stream() + for (CrySLPredicate reqPred : nextRule.getRequiredPredicates()) { + if (reqPred.equals(ensPred) && Utils.isSubType(((CrySLObject) reqPred.getParameters().get(0)).getJavaType(), predType)) { + Optional>> matchedPred = predicateConnections.stream() .filter(e -> e.getKey().equals(ensPred)).findFirst(); if (now && matchedPred.isPresent()) { - int newParNumber = getParameterNumber(curRule, (CryptSLObject) ensPred.getParameters().get(0)); - Entry> entry = matchedPred.get(); - int oldParNumber = getParameterNumber(curRule, (CryptSLObject) entry.getKey().getParameters().get(0)); + int newParNumber = getParameterNumber(curRule, (CrySLObject) ensPred.getParameters().get(0)); + Entry> entry = matchedPred.get(); + int oldParNumber = getParameterNumber(curRule, (CrySLObject) entry.getKey().getParameters().get(0)); if (newParNumber < oldParNumber) { predicateConnections.remove(entry); - predicateConnections.add(new SimpleEntry<>(ensPred, new SimpleEntry(curRule, nextRule))); + predicateConnections.add(new SimpleEntry<>(ensPred, new SimpleEntry(curRule, nextRule))); } } else { - predicateConnections.add(new SimpleEntry<>(ensPred, new SimpleEntry(curRule, nextRule))); + predicateConnections.add(new SimpleEntry<>(ensPred, new SimpleEntry(curRule, nextRule))); now = true; } } @@ -337,15 +340,15 @@ public void populatePredicateConnections(CryptSLRule curRule, CryptSLRule nextRu } } - public Optional>> determineEnsurePredicates(CryptSLRule rule, boolean lastRule) { - Optional>> toBeEnsured = Optional.empty(); + public Optional>> determineEnsurePredicates(CrySLRule rule, boolean lastRule) { + Optional>> toBeEnsured = Optional.empty(); if (lastRule) { - CryptSLObject reqReturnObject = ((CodeGenCrySLRule) rule).getRequiredRetObj(); + CrySLObject reqReturnObject = ((CodeGenCrySLRule) rule).getRequiredRetObj(); toBeEnsuredPred = null; - List candidates = new ArrayList(); - for (CryptSLPredicate reqPred : rule.getPredicates()) { - if (!(reqPred instanceof CryptSLCondPredicate)) { - String parType = ((CryptSLObject) reqPred.getParameters().get(0)).getJavaType(); + List candidates = new ArrayList(); + for (CrySLPredicate reqPred : rule.getPredicates()) { + if (!(reqPred instanceof CrySLCondPredicate)) { + String parType = ((CrySLObject) reqPred.getParameters().get(0)).getJavaType(); if (Utils.isSubType(parType, reqReturnObject.getJavaType()) || Utils.isSubType(reqReturnObject.getJavaType(), parType)) { candidates.add(reqPred); } @@ -354,26 +357,26 @@ public Optional>> determ if (candidates.size() == 1) { toBeEnsuredPred = new SimpleEntry(candidates.get(0), new SimpleEntry(rule, null)); } else if (candidates.size() > 1) { - Entry candHD = null; - for (CryptSLPredicate candidate : candidates) { + Entry candHD = null; + for (CrySLPredicate candidate : candidates) { String retName = reqReturnObject.getVarName(); - String candName = ((CryptSLObject) candidate.getParameters().get(0)).getVarName(); + String candName = ((CrySLObject) candidate.getParameters().get(0)).getVarName(); if (candHD == null) { - candHD = new SimpleEntry(candidate, getHD(retName, candName)); + candHD = new SimpleEntry(candidate, getHD(retName, candName)); } if (getHD(retName, candName) < candHD.getValue()) { - candHD = new SimpleEntry(candidate, getHD(retName, candName)); + candHD = new SimpleEntry(candidate, getHD(retName, candName)); } } toBeEnsuredPred = new SimpleEntry(candHD.getKey(), new SimpleEntry(rule, null)); } if (toBeEnsuredPred == null) { - for (CryptSLPredicate reqPred : rule.getPredicates()) { - CryptSLObject a = ((CodeGenCrySLRule) rule).getRequiredRetObj(); - Optional o = reqPred.getParameters().stream() - .filter(e -> Utils.isSubType(((CryptSLObject) e).getJavaType(), a.getJavaType())).findFirst(); + for (CrySLPredicate reqPred : rule.getPredicates()) { + CrySLObject a = ((CodeGenCrySLRule) rule).getRequiredRetObj(); + Optional o = reqPred.getParameters().stream() + .filter(e -> Utils.isSubType(((CrySLObject) e).getJavaType(), a.getJavaType())).findFirst(); if (o.isPresent()) { toBeEnsuredPred = new SimpleEntry(reqPred, new SimpleEntry(rule, null)); break; @@ -386,9 +389,9 @@ public Optional>> determ return toBeEnsured; } - public Optional>> determineEnsurePreds(CryptSLRule rule) { - Optional>> toBeEnsured; - Stream>> filter = predicateConnections.stream().filter(e -> { + public Optional>> determineEnsurePreds(CrySLRule rule) { + Optional>> toBeEnsured; + Stream>> filter = predicateConnections.stream().filter(e -> { String ruleClassName = rule.getClassName(); String keyClassName = e.getValue().getKey().getClassName(); return Utils.isSubType(ruleClassName, keyClassName) || Utils.isSubType(keyClassName, ruleClassName); @@ -421,9 +424,9 @@ public int compare(List element1, List element2) return transitions; } - public Map> determineMayUsePreds(String usedClass) { - Map> mayUsePreds = new HashMap<>(); - for (Entry> entry : predicateConnections) { + public Map> determineMayUsePreds(String usedClass) { + Map> mayUsePreds = new HashMap<>(); + for (Entry> entry : predicateConnections) { if (entry.getValue().getValue().getClassName().equals(usedClass)) { mayUsePreds.put(entry.getKey(), entry.getValue()); } @@ -466,13 +469,15 @@ private void generateTemplateUsageBody(Set generatedClasses, Gen } tmplUsage.addStatementToBody(className.toLowerCase() + "." + gen.getName() + "("); + ArrayList> usedVars = new ArrayList<>(); for (Entry par : gen.getParameters()) { if (!declaredVariables.contains(par)) { ArrayList> redundantVarList = new ArrayList<>(declaredVariables); Collections.reverse(redundantVarList); - Optional> o = redundantVarList.parallelStream().filter(e -> Utils.isSubType(e.getValue(), par.getValue())).findFirst(); + Optional> o = redundantVarList.parallelStream().filter(e -> !usedVars.contains(e) && Utils.isSubType(e.getValue(), par.getValue())).findFirst(); if (o.isPresent()) { tmplUsage.addStatementToBody(o.get().getKey() + ", "); + usedVars.add(o.get()); continue; } else { tmplUsage.addParameter(par); @@ -489,10 +494,10 @@ private void generateTemplateUsageBody(Set generatedClasses, Gen } } - private int getParameterNumber(CryptSLRule curRule, CryptSLObject par) { + private int getParameterNumber(CrySLRule curRule, CrySLObject par) { Set transitions = new HashSet(curRule.getUsagePattern().getAllTransitions()); for (TransitionEdge trans : transitions) { - for (CryptSLMethod potMethod : trans.getLabel()) { + for (CrySLMethod potMethod : trans.getLabel()) { SimpleEntry cmpPar = new SimpleEntry(par.getVarName(), par.getJavaType()); if (potMethod.getParameters().parallelStream() .anyMatch(e -> e.getKey().equals(cmpPar.getKey()) && (e.getValue().equals(cmpPar.getValue()) || e.getValue().equals(cmpPar.getValue() + "[]")))) { @@ -508,26 +513,26 @@ private int getParameterNumber(CryptSLRule curRule, CryptSLObject par) { } /** - * This method generates a method invocation for every transition of a state machine that represents a cryptsl rule. + * This method generates a method invocation for every transition of a state machine that represents a crysl rule. * * @param currentTranstions - * List of transitions that represents a cryptsl rule's state machine. + * List of transitions that represents a crysl rule's state machine. * @param currentTransitions * @param predicateConnections * @param imports */ - public ArrayList generateMethodInvocations(CodeGenCrySLRule rule, GeneratorMethod useMethod, List currentTransitions, Map> usablePreds, List imports, boolean lastRule) { + public ArrayList generateMethodInvocations(CodeGenCrySLRule rule, GeneratorMethod useMethod, List currentTransitions, Map> usablePreds, List imports, boolean lastRule) { Set killStatements = extractKillStatements(rule); ArrayList methodInvocations = new ArrayList(); List localKillers = new ArrayList(); boolean ensures = false; List> useMethodParameters = new ArrayList>(); - Entry> pre = new SimpleEntry<>(toBeEnsuredPred.getKey(), toBeEnsuredPred.getValue()); + Entry> pre = new SimpleEntry<>(toBeEnsuredPred.getKey(), toBeEnsuredPred.getValue()); for (TransitionEdge transition : currentTransitions) { Set reqMethodNames = new HashSet<>(); rule.getRequiredPars().parallelStream().forEach(e -> reqMethodNames.add(e.getMethod())); - List labels = transition.getLabel().stream().filter(e -> { + List labels = transition.getLabel().stream().filter(e -> { String methodName = e.getMethodName().substring(e.getMethodName().lastIndexOf(".") + 1); if (!reqMethodNames.contains(methodName)) { return true; @@ -547,8 +552,8 @@ public ArrayList generateMethodInvocations(CodeGenCrySLRule rule, Genera } return found.size() == objs.size(); }).collect(Collectors.toList()); - Entry entry = fetchEnsuringMethod(usablePreds, pre, labels, ensures); - CryptSLMethod method = entry.getKey(); + Entry entry = fetchEnsuringMethod(usablePreds, pre, labels, ensures); + CrySLMethod method = entry.getKey(); ensures = entry.getValue(); String methodName = method.getMethodName(); methodName = methodName.substring(methodName.lastIndexOf(".") + 1); @@ -596,18 +601,18 @@ public ArrayList generateMethodInvocations(CodeGenCrySLRule rule, Genera } } - public Set extractKillStatements(CryptSLRule rule) { - Set killStatements = rule.getPredicates().stream().filter(pred -> pred.isNegated() && pred instanceof CryptSLCondPredicate) - .map(e -> ((CryptSLCondPredicate) e).getConditionalMethods()).reduce(new HashSet<>(), (a, b) -> { + public Set extractKillStatements(CrySLRule rule) { + Set killStatements = rule.getPredicates().stream().filter(pred -> pred.isNegated() && pred instanceof CrySLCondPredicate) + .map(e -> ((CrySLCondPredicate) e).getConditionalMethods()).reduce(new HashSet<>(), (a, b) -> { a.addAll(b); return a; }); return killStatements; } - public Entry fetchEnsuringMethod(Map> usablePreds, Entry> pre, List labels, boolean ensures) { - CryptSLMethod method = null; - for (CryptSLMethod meth : labels) { + public Entry fetchEnsuringMethod(Map> usablePreds, Entry> pre, List labels, boolean ensures) { + CrySLMethod method = null; + for (CrySLMethod meth : labels) { if (method != null) { break; } else { @@ -622,7 +627,7 @@ public Entry fetchEnsuringMethod(Map> usablePred : usablePreds.entrySet()) { + for (Entry> usablePred : usablePreds.entrySet()) { if (method == null) { method = fetchCorrespondingMethod(usablePred, meth, null); } else { @@ -635,11 +640,11 @@ public Entry fetchEnsuringMethod(Map(method, ensures); + return new AbstractMap.SimpleEntry(method, ensures); } - private CryptSLMethod fetchCorrespondingMethod(Entry> pred, CryptSLMethod meth, Set set) { - CryptSLObject objectOfPred = (CryptSLObject) pred.getKey().getParameters().get(0); + private CrySLMethod fetchCorrespondingMethod(Entry> pred, CrySLMethod meth, Set set) { + CrySLObject objectOfPred = (CrySLObject) pred.getKey().getParameters().get(0); String predVarType = objectOfPred.getJavaType(); String predVarName = objectOfPred.getVarName(); @@ -726,15 +731,14 @@ public Class[] collectParameterTypes(List> parameters) methodParameter[i] = Class.forName(parameter.getValue()); i++; } catch (ClassNotFoundException e) { - System.out.println("No class found for type: " + parameter.getValue().toString()); - e.printStackTrace(); + Activator.getDefault().logError(e, "No class found for type: " + parameter.getValue().toString()); } } } return methodParameter; } - private Entry>> generateMethodInvocation(GeneratorMethod useMethod, String lastInvokedMethod, List imports, CryptSLMethod method, String methodName, List> parameters, CodeGenCrySLRule rule, StringBuilder currentInvokedMethod, boolean lastRule) { + private Entry>> generateMethodInvocation(GeneratorMethod useMethod, String lastInvokedMethod, List imports, CrySLMethod method, String methodName, List> parameters, CodeGenCrySLRule rule, StringBuilder currentInvokedMethod, boolean lastRule) { // Generate method invocation. Hereafter, a method call is distinguished in three categories. String methodInvocation = ""; @@ -747,7 +751,7 @@ private Entry>> generateMethodInvocation(Gene // 3. Instance method calls // 1. Constructor method call - CryptSLObject retObjInTemplate = rule.getRequiredRetObj(); + CrySLObject retObjInTemplate = rule.getRequiredRetObj(); if (currentInvokedMethod.substring(0, currentInvokedMethod.indexOf("(")).equals(simpleName)) { if (lastRule && retObjInTemplate != null && (Utils.isSubType(className, retObjInTemplate.getJavaType()) || Utils.isSubType(retObjInTemplate.getJavaType(), className))) { @@ -843,12 +847,17 @@ private Entry>> replaceParameterByValue(CodeG List> declaredVariables = useMethod.getDeclaredVariables(); List reqPars = rule.getRequiredPars(); + List> usedVars = new ArrayList>(); + reqPars.stream().forEach(e -> usedVars.add(new SimpleEntry<>(e.getVarName(), e.getJavaType()))); + if (rule.getRequiredRetObj() != null) { + usedVars.add(new SimpleEntry(rule.getRequiredRetObj().getVarName(), rule.getRequiredRetObj().getJavaType())); + } + for (Entry parameter : parametersOfCall) { boolean inTemplate = false; for (CodeGenCrySLObject par : reqPars) { - if (methodNamdResultAssignment - .endsWith(par.getMethod()) && par.getCrySLVariable().equals(parameter.getKey())) { + if (methodNamdResultAssignment.endsWith(par.getMethod()) && par.getCrySLVariable().equals(parameter.getKey())) { methodParameter = methodParameter.replace(parameter.getKey(), par.getVarName()); updateToBeEnsured(new SimpleEntry(par.getVarName(), parameter.getValue())); inTemplate = true; @@ -859,32 +868,24 @@ private Entry>> replaceParameterByValue(CodeG continue; } - Optional>> entry = predicateConnections.stream().filter( + Optional>> entry = predicateConnections.stream().filter( e -> Utils.isSubType(e.getValue().getValue().getClassName(), rule.getClassName()) || Utils.isSubType(rule.getClassName(), e.getValue().getValue().getClassName())) .findFirst(); if (entry.isPresent()) { - final CryptSLObject cryptSLObject = (CryptSLObject) entry.get().getKey().getParameters().get(0); - if (!"this".equals(cryptSLObject.getVarName())) { - if ((Utils.isSubType(cryptSLObject.getJavaType(), parameter.getValue()) || Utils.isSubType(parameter.getValue(), cryptSLObject.getJavaType()))) { - methodParameter = methodParameter.replace(parameter.getKey(), cryptSLObject.getVarName()); + + final CrySLObject crySLObject = (CrySLObject) entry.get().getKey().getParameters().get(0); + if (!"this".equals(crySLObject.getVarName())) { + if (usedVars.contains(new SimpleEntry(crySLObject.getVarName(), crySLObject.getJavaType())) && (Utils.isSubType(crySLObject.getJavaType(), + parameter.getValue()) || Utils.isSubType(parameter.getValue(), crySLObject.getJavaType()))) { + methodParameter = methodParameter.replace(parameter.getKey(), crySLObject.getVarName()); continue; } } } - int index = useMethod.getNumberOfVariablesInTemplate(); - List> tmpVariables = new ArrayList<>(); - if (declaredVariables.size() > index) { - tmpVariables.add(declaredVariables.get(declaredVariables.size() - 1)); - } - for (Entry declVar : declaredVariables.subList(0, index)) { - if (reqPars.parallelStream().noneMatch(e -> e.getVarName().equals(declVar.getKey()))) { - tmpVariables.add(declVar); - } - } - List> declVariables = declaredVariables.subList(index, declaredVariables.size()); - Collections.reverse(declVariables); - tmpVariables.addAll(declVariables); + List> tmpVariables = new ArrayList<>(); + declaredVariables.stream().filter(e -> !usedVars.contains(e)).filter(e -> !useMethod.getPostCGVars().contains(e)).forEach(e -> tmpVariables.add(e)); + Collections.reverse(tmpVariables); Optional> typeMatch = tmpVariables.stream() .filter(e -> (Utils.isSubType(e.getValue(), parameter.getValue()) || Utils.isSubType(parameter.getValue(), e.getValue()))).findFirst(); @@ -915,6 +916,7 @@ private Entry>> replaceParameterByValue(CodeG currentInvokedMethod = methodNamdResultAssignment + methodParameter + appendix; return new SimpleEntry<>(currentInvokedMethod, parametersOfUseMethod); + } /** @@ -930,8 +932,8 @@ public String analyseConstraints(Entry parameter, CodeGenCrySLRu List constraints = rule.getConstraints().stream().filter(e -> e.getInvolvedVarNames().contains(parameter.getKey())).collect(Collectors.toList()); for (ISLConstraint constraint : constraints) { - // handle CryptSLValueConstraint - String name = resolveCryptSLConstraint(parameter, constraint, methodName, rule.getRequiredPars()); + // handle CrySLValueConstraint + String name = resolveCrySLConstraint(parameter, constraint, methodName, rule.getRequiredPars()); if (!name.isEmpty()) { if ("java.lang.String".equals(parameter.getValue())) { name = "\"" + name + "\""; @@ -944,12 +946,12 @@ public String analyseConstraints(Entry parameter, CodeGenCrySLRu return ""; } - private String resolveCryptSLConstraint(Entry parameter, ISLConstraint constraint, String methodName, List list) { - return resolveCryptSLConstraint(parameter, constraint, methodName, list, false); + private String resolveCrySLConstraint(Entry parameter, ISLConstraint constraint, String methodName, List list) { + return resolveCrySLConstraint(parameter, constraint, methodName, list, false); } /** - * This method resolves constraints of a cryptsl rule recursively. + * This method resolves constraints of a crysl rule recursively. * * @param parameter * @@ -958,10 +960,10 @@ private String resolveCryptSLConstraint(Entry parameter, ISLCons * @param methodName * @return Returns true if the given constraint object describes a valid logical expression otherwise false. */ - private String resolveCryptSLConstraint(Entry parameter, ISLConstraint constraint, String methodName, List list, boolean onlyEval) { + private String resolveCrySLConstraint(Entry parameter, ISLConstraint constraint, String methodName, List list, boolean onlyEval) { String parVarName = parameter.getKey(); - if (constraint instanceof CryptSLValueConstraint) { - CryptSLValueConstraint asVC = (CryptSLValueConstraint) constraint; + if (constraint instanceof CrySLValueConstraint) { + CrySLValueConstraint asVC = (CrySLValueConstraint) constraint; String constraintValue = asVC.getValueRange().get(0); if (onlyEval) { if (ruleParameterCache.containsKey(parVarName) && asVC.getValueRange().contains(ruleParameterCache.get(parVarName))) { @@ -974,11 +976,11 @@ private String resolveCryptSLConstraint(Entry parameter, ISLCons ruleParameterCache.putIfAbsent(parVarName, constraintValue); return constraintValue; } - } else if (constraint instanceof CryptSLComparisonConstraint) { - CryptSLComparisonConstraint comp = (CryptSLComparisonConstraint) constraint; - if (comp.getLeft().getLeft() instanceof CryptSLObject && comp.getRight().getLeft() instanceof CryptSLObject) { - CryptSLObject left = (CryptSLObject) comp.getLeft().getLeft(); - CryptSLObject right = (CryptSLObject) comp.getRight().getLeft(); + } else if (constraint instanceof CrySLComparisonConstraint) { + CrySLComparisonConstraint comp = (CrySLComparisonConstraint) constraint; + if (comp.getLeft().getLeft() instanceof CrySLObject && comp.getRight().getLeft() instanceof CrySLObject) { + CrySLObject left = (CrySLObject) comp.getLeft().getLeft(); + CrySLObject right = (CrySLObject) comp.getRight().getLeft(); int value = Integer.MIN_VALUE; String varName = ""; try { @@ -1018,68 +1020,68 @@ private String resolveCryptSLConstraint(Entry parameter, ISLCons parameterCache.putIfAbsent(varName, secureInt); return secureInt; } - } else if (constraint instanceof CryptSLPredicate && "instanceOf".equals(((CryptSLPredicate) constraint).getPredName())) { + } else if (constraint instanceof CrySLPredicate && "instanceOf".equals(((CrySLPredicate) constraint).getPredName())) { for (CodeGenCrySLObject obj : list) { - List instanceOfPred = ((CryptSLPredicate) constraint).getParameters(); - if (((CryptSLObject) instanceOfPred.get(1)).getVarName().equals(obj.getJavaType()) && obj.getMethod() - .equals(findMethodForParameter((CryptSLObject) instanceOfPred.get(0)))) { - return ((CryptSLObject) instanceOfPred.get(0)).getVarName(); + List instanceOfPred = ((CrySLPredicate) constraint).getParameters(); + if (((CrySLObject) instanceOfPred.get(1)).getVarName().equals(obj.getJavaType()) && obj.getMethod() + .equals(findMethodForParameter((CrySLObject) instanceOfPred.get(0)))) { + return ((CrySLObject) instanceOfPred.get(0)).getVarName(); } } - } else if (constraint instanceof CryptSLConstraint) { + } else if (constraint instanceof CrySLConstraint) { - CryptSLConstraint cryptSLConstraint = (CryptSLConstraint) constraint; - LogOps operator = cryptSLConstraint.getOperator(); - ISLConstraint left = cryptSLConstraint.getLeft(); - ISLConstraint right = cryptSLConstraint.getRight(); + CrySLConstraint crySLConstraint = (CrySLConstraint) constraint; + LogOps operator = crySLConstraint.getOperator(); + ISLConstraint left = crySLConstraint.getLeft(); + ISLConstraint right = crySLConstraint.getRight(); Entry leftAlternative = new SimpleEntry(left.getInvolvedVarNames().iterator().next(), parameter.getValue()); Entry rightAlternative = new SimpleEntry(right.getInvolvedVarNames().iterator().next(), parameter.getValue()); if (operator == LogOps.and) { if (left.getInvolvedVarNames().contains(parVarName)) { if (!right.getInvolvedVarNames().contains(parVarName)) { - if (!resolveCryptSLConstraint(parameter, right, methodName, list, true).isEmpty()) { - return resolveCryptSLConstraint(parameter, left, methodName, list); + if (!resolveCrySLConstraint(parameter, right, methodName, list, true).isEmpty()) { + return resolveCrySLConstraint(parameter, left, methodName, list); } else { return ""; } } else { - if (resolveCryptSLConstraint(parameter, left, methodName, list, true).isEmpty()) { - return resolveCryptSLConstraint(parameter, right, methodName, list); + if (resolveCrySLConstraint(parameter, left, methodName, list, true).isEmpty()) { + return resolveCrySLConstraint(parameter, right, methodName, list); } else { - return resolveCryptSLConstraint(parameter, left, methodName, list); + return resolveCrySLConstraint(parameter, left, methodName, list); } } - } else if (!resolveCryptSLConstraint(parameter, left, methodName, list).isEmpty()) { - return resolveCryptSLConstraint(parameter, right, methodName, list); + } else if (!resolveCrySLConstraint(parameter, left, methodName, list).isEmpty()) { + return resolveCrySLConstraint(parameter, right, methodName, list); } return ""; } else if (operator == LogOps.or) { if (!onlyEval) { if (left.getInvolvedVarNames().contains(parVarName)) { - if (resolveCryptSLConstraint(parameter, left, methodName, list).isEmpty()) { - if (right.getInvolvedVarNames().contains(parVarName) && !resolveCryptSLConstraint(parameter, right, methodName, list, true).isEmpty()) { - return resolveCryptSLConstraint(parameter, right, methodName, list); + if (resolveCrySLConstraint(parameter, left, methodName, list).isEmpty()) { + if (right.getInvolvedVarNames().contains(parVarName) && !resolveCrySLConstraint(parameter, right, methodName, list, true).isEmpty()) { + return resolveCrySLConstraint(parameter, right, methodName, list); } else { return ""; } } - return resolveCryptSLConstraint(parameter, left, methodName, list); + return resolveCrySLConstraint(parameter, left, methodName, list); } - return resolveCryptSLConstraint(parameter, right, methodName, list); + return resolveCrySLConstraint(parameter, right, methodName, list); } else { - String leftResult = resolveCryptSLConstraint(parameter, left, methodName, list, onlyEval); + String leftResult = resolveCrySLConstraint(parameter, left, methodName, list, onlyEval); if (!leftResult.isEmpty()) { return leftResult; } else { - return resolveCryptSLConstraint(rightAlternative, right, methodName, list, onlyEval); + return resolveCrySLConstraint(rightAlternative, right, methodName, list, onlyEval); } } } else if (operator == LogOps.implies) { - if (!right.getInvolvedVarNames().contains(parVarName) || resolveCryptSLConstraint(leftAlternative, left, methodName, list, true).isEmpty()) { + if (!right.getInvolvedVarNames().contains(parVarName) || resolveCrySLConstraint(leftAlternative, left, methodName, list, true).isEmpty()) { return ""; } - return resolveCryptSLConstraint(parameter, right, methodName, list); + return resolveCrySLConstraint(parameter, right, methodName, list); } else { return ""; // invalid operator } @@ -1091,10 +1093,10 @@ private String dealWithCipherGetInstance() { String mode = ""; String pad = ""; List constraints = curRule.getConstraints().parallelStream().filter(e -> e.getInvolvedVarNames().contains("transformation")) - .filter(e -> e instanceof CryptSLConstraint && ((CryptSLConstraint) e).getLeft().getName().contains("AES")).collect(Collectors.toList()); + .filter(e -> e instanceof CrySLConstraint && ((CrySLConstraint) e).getLeft().getName().contains("AES")).collect(Collectors.toList()); for (ISLConstraint cons : constraints) { - if (cons instanceof CryptSLConstraint && ((CryptSLConstraint) cons).getOperator() == LogOps.implies) { - CryptSLValueConstraint valCons = (CryptSLValueConstraint) ((CryptSLConstraint) cons).getRight(); + if (cons instanceof CrySLConstraint && ((CrySLConstraint) cons).getOperator() == LogOps.implies) { + CrySLValueConstraint valCons = (CrySLValueConstraint) ((CrySLConstraint) cons).getRight(); int pos = valCons.getVar().getSplitter().getIndex(); if (pos == 1 && mode.isEmpty()) { mode = valCons.getValueRange().get(0); @@ -1113,10 +1115,10 @@ private String dealWithCipherGetInstance() { return "/" + mode + "/" + pad; } - private String findMethodForParameter(CryptSLObject cryptSLObject) { + private String findMethodForParameter(CrySLObject crySLObject) { for (TransitionEdge te : curRule.getUsagePattern().getAllTransitions()) { - for (CryptSLMethod method : te.getLabel()) { - if (method.getParameters().parallelStream().anyMatch(f -> f.getKey().equals(cryptSLObject.getVarName()) && f.getValue().equals(cryptSLObject.getJavaType()))) { + for (CrySLMethod method : te.getLabel()) { + if (method.getParameters().parallelStream().anyMatch(f -> f.getKey().equals(crySLObject.getVarName()) && f.getValue().equals(crySLObject.getJavaType()))) { return method.getMethodName().substring(method.getMethodName().lastIndexOf(".") + 1); } } @@ -1125,29 +1127,29 @@ private String findMethodForParameter(CryptSLObject cryptSLObject) { } /** - * Returns the last invoked method of a CryptSLMethod object sequence. + * Returns the last invoked method of a CrySLMethod object sequence. * * @param transitions * Sequence * @return Last invoked method. */ - private CryptSLMethod getLastInvokedMethod(List transitions) { + private CrySLMethod getLastInvokedMethod(List transitions) { // Get last transition TransitionEdge lastTransition = transitions.get(transitions.size() - 1); // Get last - CryptSLMethod lastInvokedMethod = lastTransition.getLabel().get(0); + CrySLMethod lastInvokedMethod = lastTransition.getLabel().get(0); return lastInvokedMethod; } /** - * Returns the name of the last method that is used by the currently analysed cryptsl API-rule + * Returns the name of the last method that is used by the currently analysed crysl API-rule * * @param transitions - * All transitions of a state machine that describes a cryptsl API-rule + * All transitions of a state machine that describes a crysl API-rule * - * @return Name of the last method that is used by the currently analysed cryptsl API-rule. + * @return Name of the last method that is used by the currently analysed crysl API-rule. */ public String getLastInvokedMethodName(List transitions) { String lastInvokedMethodName = getLastInvokedMethod(transitions).toString(); @@ -1232,19 +1234,19 @@ private boolean matchMethodParameters(Class[] methodParameters, Class[] cl public void updateToBeEnsured(Entry entry) { if (toBeEnsuredPred != null) { - CryptSLPredicate existing = toBeEnsuredPred.getKey(); - CryptSLObject predicatePar = (CryptSLObject) existing.getParameters().get(0); + CrySLPredicate existing = toBeEnsuredPred.getKey(); + CrySLObject predicatePar = (CrySLObject) existing.getParameters().get(0); if (!"this".equals(predicatePar.getVarName())) { - List parameters = new ArrayList(); - for (ICryptSLPredicateParameter obj : existing.getParameters()) { - CryptSLObject par = ((CryptSLObject) obj); + List parameters = new ArrayList(); + for (ICrySLPredicateParameter obj : existing.getParameters()) { + CrySLObject par = ((CrySLObject) obj); if (Utils.isSubType(par.getJavaType(), predicatePar.getJavaType()) || Utils.isSubType(predicatePar.getJavaType(), par.getJavaType())) { - parameters.add(new CryptSLObject(entry.getKey(), par.getJavaType(), par.getSplitter())); + parameters.add(new CrySLObject(entry.getKey(), par.getJavaType(), par.getSplitter())); } } if (!parameters.isEmpty()) { - toBeEnsuredPred = new SimpleEntry>(new CryptSLPredicate(existing.getBaseObject(), existing + toBeEnsuredPred = new SimpleEntry>(new CrySLPredicate(existing.getBaseObject(), existing .getPredName(), parameters, existing.isNegated(), existing.getConstraint()), toBeEnsuredPred.getValue()); } } @@ -1266,13 +1268,14 @@ public GeneratorClass setUpTemplateClass(String pathToTemplateFile) { final ASTVisitor astVisitor = new ASTVisitor(true) { GeneratorMethod curMethod = null; - CryptSLObject retObj = null; + CrySLObject retObj = null; List pars = new ArrayList<>(); - Map variableDefinitions = new HashMap(); - + Map preCGVars = new HashMap(); + Map postCGVars = new HashMap(); + List rules = new ArrayList(); - @SuppressWarnings("unchecked") + @SuppressWarnings({ "unchecked", "rawtypes" }) @Override public boolean visit(MethodInvocation node) { MethodInvocation mi = node; @@ -1280,25 +1283,25 @@ public boolean visit(MethodInvocation node) { List arguments = mi.arguments(); if ("addReturnObject".equals(calledMethodName)) { - for (SimpleName var : variableDefinitions.keySet()) { + for (SimpleName var : preCGVars.keySet()) { String varfqn = var.getFullyQualifiedName(); for (SimpleName name : (List) arguments) { String efqn = name.getFullyQualifiedName(); if (efqn.equals(varfqn)) { - CryptSLObject cryptSLObject = variableDefinitions.get(var); - retObj = cryptSLObject; + CrySLObject crySLObject = preCGVars.get(var); + retObj = crySLObject; break; } } } } else if ("addParameter".equals(calledMethodName)) { - for (SimpleName var : variableDefinitions.keySet()) { + for (SimpleName var : preCGVars.keySet()) { String varfqn = var.getFullyQualifiedName(); SimpleName name = (SimpleName) arguments.get(0); String efqn = name.getFullyQualifiedName(); if (efqn.equals(varfqn)) { - pars.add(new CodeGenCrySLObject(variableDefinitions.get(var), (String) ((StringLiteral) arguments.get(1)).resolveConstantExpressionValue())); + pars.add(new CodeGenCrySLObject(preCGVars.get(var), (String) ((StringLiteral) arguments.get(1)).resolveConstantExpressionValue())); break; } } @@ -1306,10 +1309,10 @@ public boolean visit(MethodInvocation node) { String rule = Utils.filterQuotes(arguments.get(0).toString()); String simpleRuleName = rule.substring(rule.lastIndexOf(".") + 1); try { - CryptSLRule cryptSLRule = Utils.getCryptSLRule(simpleRuleName); + CrySLRule crySLRule = CrySLUtils.getCrySLRule(simpleRuleName); for (CodeGenCrySLObject o : pars) { - for (TransitionEdge edge : cryptSLRule.getUsagePattern().getEdges()) { - for (CryptSLMethod method : edge.getLabel()) { + for (TransitionEdge edge : crySLRule.getUsagePattern().getEdges()) { + for (CrySLMethod method : edge.getLabel()) { List> parameters = method.getParameters(); for (int i = 0; i < parameters.size(); i++) { if (parameters.get(i).getKey().equals(o.getCrySLVariable())) { @@ -1319,7 +1322,7 @@ public boolean visit(MethodInvocation node) { } } } - rules.add(new CodeGenCrySLRule(cryptSLRule, pars, retObj)); + rules.add(new CodeGenCrySLRule(crySLRule, pars, retObj)); } catch (MalformedURLException e) { Activator.getDefault().logError(e); } @@ -1345,7 +1348,20 @@ public void postVisit(ASTNode node) { @Override public boolean visit(VariableDeclarationStatement node) { SimpleName varName = ((VariableDeclarationFragment) ((VariableDeclarationStatement) node).fragments().get(0)).getName(); - variableDefinitions.put(varName, new CryptSLObject(varName.getFullyQualifiedName(), ((VariableDeclarationStatement) node).getType().toString())); + int codeGenStmt = -1; + for (Object s : ((Block) node.getParent()).statements()) { + Statement statement = (Statement) s; + if (s instanceof ExpressionStatement && ((ExpressionStatement) s).toString().contains("CrySLCodeGenerator") ) { + codeGenStmt = statement.getStartPosition(); + break; + } + } + + if(node.getStartPosition() < codeGenStmt) { + preCGVars.put(varName, new CrySLObject(varName.getFullyQualifiedName(), ((VariableDeclarationStatement) node).getType().toString())); + } else { + postCGVars.put(varName, new CrySLObject(varName.getFullyQualifiedName(), ((VariableDeclarationStatement) node).getType().toString())); + } return super.visit(node); } @@ -1362,7 +1378,7 @@ public boolean visit(MethodDeclaration node) { } for (SingleVariableDeclaration svd : (List) node.parameters()) { - variableDefinitions.put(svd.getName(), new CryptSLObject(svd.getName().getFullyQualifiedName(), svd.getType().toString())); + preCGVars.put(svd.getName(), new CrySLObject(svd.getName().getFullyQualifiedName(), svd.getType().toString())); curMethod.addParameter(new SimpleEntry(svd.getName().getFullyQualifiedName(), svd.getType().toString())); } curMethod.setNumberOfVariablesInTemplate(curMethod.getDeclaredVariables().size()); @@ -1374,6 +1390,7 @@ public boolean visit(MethodDeclaration node) { public void endVisit(MethodDeclaration node) { Collections.reverse(rules); curMethod.setRules(new ArrayList<>(rules)); + postCGVars.entrySet().forEach(e -> curMethod.addPostCGVars(new SimpleEntry(e.getKey().getFullyQualifiedName(), e.getValue().getJavaType()))); rules.clear(); super.visit(node); } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLComparator.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLComparator.java index 4f14710f2..81da644af 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLComparator.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/CrySLComparator.java @@ -12,19 +12,19 @@ import java.util.Comparator; -import crypto.rules.CryptSLRule; -import de.cognicrypt.utils.Utils; +import crypto.rules.CrySLRule; +import de.cognicrypt.utils.CrySLUtils; -public class CrySLComparator implements Comparator { +public class CrySLComparator implements Comparator { RuleDependencyTree rdt; public CrySLComparator() { - rdt = new RuleDependencyTree(Utils.readCrySLRules()); + rdt = new RuleDependencyTree(CrySLUtils.readCrySLRules()); } @Override - public int compare(CryptSLRule left, CryptSLRule right) { + public int compare(CrySLRule left, CrySLRule right) { if (rdt.hasPath(left, right)) { return -1; } else if (rdt.hasPath(right, left)) { diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/GeneratorMethod.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/GeneratorMethod.java index 8c1291fc1..23a5a4085 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/GeneratorMethod.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/GeneratorMethod.java @@ -27,6 +27,7 @@ public class GeneratorMethod { private Set exceptions; private StringBuilder body; private List> variableDeclarations; + private List> postCGVars; private StringBuilder killStatements; private int templateVariables; private List cryslRules; @@ -34,6 +35,7 @@ public class GeneratorMethod { public GeneratorMethod() { body = new StringBuilder(); variableDeclarations = new ArrayList>(); + postCGVars = new ArrayList>(); parameters = new ArrayList>(); exceptions = new HashSet(); } @@ -180,5 +182,13 @@ public void setRules(List rules) { public List getRules() { return cryslRules; } + + public void addPostCGVars(Entry postCGVar) { + postCGVars.add(postCGVar); + } + + public List> getPostCGVars() { + return postCGVars; + } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/RuleDependencyTree.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/RuleDependencyTree.java index c4e663bc1..696bf0769 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/RuleDependencyTree.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/RuleDependencyTree.java @@ -23,32 +23,32 @@ import java.util.Set; import java.util.stream.Collectors; -import crypto.rules.CryptSLObject; -import crypto.rules.CryptSLPredicate; -import crypto.rules.CryptSLRule; +import crypto.rules.CrySLObject; +import crypto.rules.CrySLPredicate; +import crypto.rules.CrySLRule; import de.cognicrypt.utils.Utils; public class RuleDependencyTree { - List cryslRules; + List cryslRules; - List nodes; + List nodes; - Map> ruleToPred; - List, String>> edges; + Map> ruleToPred; + List, String>> edges; - public RuleDependencyTree(List rules) { - nodes = new ArrayList(); - edges = new ArrayList, String>>(); - ruleToPred = new HashMap>(); + public RuleDependencyTree(List rules) { + nodes = new ArrayList(); + edges = new ArrayList, String>>(); + ruleToPred = new HashMap>(); - for (CryptSLRule rule : rules) { + for (CrySLRule rule : rules) { nodes.add(rule); - for (CryptSLPredicate pred : rule.getPredicates()) { + for (CrySLPredicate pred : rule.getPredicates()) { if (!pred.isNegated()) { - Set predsForRule = ruleToPred.get(pred.getPredName()); + Set predsForRule = ruleToPred.get(pred.getPredName()); if (predsForRule == null) { - ruleToPred.put(pred.getPredName(), new HashSet()); + ruleToPred.put(pred.getPredName(), new HashSet()); predsForRule = ruleToPred.get(pred.getPredName()); } predsForRule.add(rule); @@ -56,16 +56,16 @@ public RuleDependencyTree(List rules) { } } - for (CryptSLRule rule : rules) { - for (CryptSLPredicate pred : rule.getRequiredPredicates()) { - Set allPreds = ruleToPred.get(pred.getPredName()); + for (CrySLRule rule : rules) { + for (CrySLPredicate pred : rule.getRequiredPredicates()) { + Set allPreds = ruleToPred.get(pred.getPredName()); if (allPreds == null) { continue; } - for (CryptSLRule predicate : allPreds) { + for (CrySLRule predicate : allPreds) { if (predicate != null) { - Entry rulePair = new SimpleEntry(predicate, rule); - SimpleEntry, String> predRuleEntry = new SimpleEntry, String>(rulePair, pred.getPredName()); + Entry rulePair = new SimpleEntry(predicate, rule); + SimpleEntry, String> predRuleEntry = new SimpleEntry, String>(rulePair, pred.getPredName()); edges.add(predRuleEntry); } } @@ -75,8 +75,8 @@ public RuleDependencyTree(List rules) { public void toDotFile(String rulesFolder) { StringBuilder dotFileSB = new StringBuilder("digraph F {\n"); - for (Entry, String> edge : edges) { - Entry nodes = edge.getKey(); + for (Entry, String> edge : edges) { + Entry nodes = edge.getKey(); dotFileSB.append(nodes.getValue()); dotFileSB.append(" -> "); dotFileSB.append(nodes.getKey()); @@ -96,18 +96,18 @@ public void toDotFile(String rulesFolder) { * [label="javax.crypto.KeyGenerator.init(int)"]; 1 -> 2 [label="javax.crypto.KeyGenerator.generateK"]; 0 -> 2 [label="javax.crypto.KeyGenerator.generateK"]; } */ - public boolean hasPath(CryptSLRule start, CryptSLRule goal) { - Set visited = new HashSet(); + public boolean hasPath(CrySLRule start, CrySLRule goal) { + Set visited = new HashSet(); visited.add(start); - Set toBeVisited = new HashSet(); + Set toBeVisited = new HashSet(); toBeVisited.add(start); while (visited.size() != nodes.size()) { - Set rights = new HashSet(); - for (CryptSLRule node : toBeVisited) { - for (Entry, String> edge : edges) { - Entry nodes = edge.getKey(); - CryptSLRule right = nodes.getValue(); + Set rights = new HashSet(); + for (CrySLRule node : toBeVisited) { + for (Entry, String> edge : edges) { + Entry nodes = edge.getKey(); + CrySLRule right = nodes.getValue(); if (nodes.getKey().equals(node) && !visited.contains(right)) { rights.add(right); } @@ -126,15 +126,15 @@ public boolean hasPath(CryptSLRule start, CryptSLRule goal) { return false; } - public boolean hasDirectPath(CryptSLRule start, CryptSLRule goal) { + public boolean hasDirectPath(CrySLRule start, CrySLRule goal) { return getOutgoingEdges(start).stream().anyMatch(entry -> entry.getKey().getValue().equals(goal)) || start.getPredicates().stream().anyMatch(predicate -> { - String predType = ((CryptSLObject) predicate.getParameters().get(0)).getJavaType(); + String predType = ((CrySLObject) predicate.getParameters().get(0)).getJavaType(); String goalType = goal.getClassName(); return Utils.isSubType(predType, goalType) || Utils.isSubType(goalType, predType); }); } - public List, String>> getOutgoingEdges(CryptSLRule node) { + public List, String>> getOutgoingEdges(CrySLRule node) { return edges.stream().filter(entry -> entry.getKey().getKey().equals(node)).collect(Collectors.toList()); } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/StateMachineGraphAnalyser.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/StateMachineGraphAnalyser.java index 2630e35c5..f20815ec3 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/StateMachineGraphAnalyser.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/StateMachineGraphAnalyser.java @@ -16,7 +16,7 @@ import crypto.rules.StateMachineGraph; import crypto.rules.StateNode; import crypto.rules.TransitionEdge; -import de.cognicrypt.utils.Utils; +import de.cognicrypt.utils.CrySLUtils; /** * @@ -41,7 +41,7 @@ public StateMachineGraphAnalyser(StateMachineGraph stateMachine) { // FIXME loop handling // Current solution: Take every loop once. // This solution does not distinguish between the two operates - // + and * of the cryptsl language + // + and * of the crysl language public ArrayList> getTransitions() throws Exception { allTransitions = new ArrayList>(); @@ -75,7 +75,7 @@ private void visitNode(List edges, TransitionEdge currentTransit //usedTransitions.add(currentNode.getName()); // get all adjacent nodes from the current node - transitionsToAdjacentNodes.addAll(Utils.getOutgoingEdges(stateMachine.getAllTransitions(), currentTransition.getRight(), currentTransition.getRight())); + transitionsToAdjacentNodes.addAll(CrySLUtils.getOutgoingEdges(stateMachine.getAllTransitions(), currentTransition.getRight(), currentTransition.getRight())); // for (TransitionEdge edge : edges) { // // if (edge.getLeft().getName().equals(currentTransition.getRight().getName())) diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/XSLBasedGenerator.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/XSLBasedGenerator.java index eab75bb3e..9fb5ca038 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/XSLBasedGenerator.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/generator/XSLBasedGenerator.java @@ -38,7 +38,7 @@ import de.cognicrypt.codegenerator.utilities.CodeGenUtils; import de.cognicrypt.codegenerator.wizard.Configuration; import de.cognicrypt.core.Constants; -import de.cognicrypt.utils.FileHelper; +import de.cognicrypt.utils.FileUtils; /** * This class is responsible for generating code templates by performing an XSL transformation. Currently, Saxon is used as an XSLT- processor. @@ -97,7 +97,7 @@ public boolean generateCodeTemplates(final Configuration chosenConfig, final Str } // Trim Output.java - FileHelper.trimFile(temporaryOutputFile); + FileUtils.trimFile(temporaryOutputFile); // Add additional resources like jar files if (!addAdditionalFiles(pathToAdditionalResources)) { @@ -112,7 +112,7 @@ public boolean generateCodeTemplates(final Configuration chosenConfig, final Str if (targetFile != null && this.project.equals(targetFile.getProject())) { Activator.getDefault().logInfo(Constants.OpenFile + targetFile.getName()); - if (FileHelper.checkFileForString(targetFile.getRawLocation().toOSString(), Constants.AuthorTag)) { + if (FileUtils.checkFileForString(targetFile.getRawLocation().toOSString(), Constants.AuthorTag)) { Activator.getDefault().logInfo(Constants.ContainsAuthorTag + targetFile.getName()); insertCallCodeIntoFile(temporaryOutputFile, true, true, tempFlag); removeCryptoPackageIfEmpty(); diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/preferences/CodeGenPreferences.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/preferences/CodeGenPreferences.java index d5f5d31ca..603ff9d75 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/preferences/CodeGenPreferences.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/preferences/CodeGenPreferences.java @@ -19,7 +19,7 @@ import de.cognicrypt.codegenerator.Activator; import de.cognicrypt.core.Constants; import de.cognicrypt.core.properties.PreferenceListener; -import de.cognicrypt.utils.Utils; +import de.cognicrypt.utils.UIUtils; public class CodeGenPreferences extends PreferenceListener { @@ -34,7 +34,7 @@ public void compileBasicPreferences(Composite parent) { @Override public void compileAdvancedPreferences(Composite parent) { - final Group codeGenGroup = Utils.addHeaderGroup(parent, "Code Generator"); + final Group codeGenGroup = UIUtils.addHeaderGroup(parent, "Code Generator"); persistConfig = new Button(codeGenGroup, SWT.CHECK); persistConfig.setText("Persist Code-generation Configuration"); diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/ui/contentassist/CustomCompletionProposalComputer.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/ui/contentassist/CustomCompletionProposalComputer.java new file mode 100644 index 000000000..9ce3c6fc3 --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/ui/contentassist/CustomCompletionProposalComputer.java @@ -0,0 +1,93 @@ +package de.cognicrypt.codegenerator.ui.contentassist; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.core.runtime.IProgressMonitor; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.internal.ui.text.java.JavaCompletionProposalComputer; +import org.eclipse.jdt.ui.text.java.ContentAssistInvocationContext; +import org.eclipse.jdt.ui.text.java.JavaContentAssistInvocationContext; +import org.eclipse.jface.text.contentassist.CompletionProposal; +import org.eclipse.jface.text.contentassist.ICompletionProposal; + +import de.cognicrypt.codegenerator.Activator; +import de.cognicrypt.core.Constants; + + +@SuppressWarnings("restriction") +public class CustomCompletionProposalComputer extends JavaCompletionProposalComputer { + + + static private List ruleNames = readClassnames(Constants.JCA_LATEST_ECLIPSE_RULES_DIR); + + @Override + public List computeCompletionProposals(ContentAssistInvocationContext context, IProgressMonitor monitor) { + List defaultProposals = super.computeCompletionProposals(context, monitor); + + JavaContentAssistInvocationContext javaContext = (JavaContentAssistInvocationContext) context; + ICompilationUnit cu = javaContext.getCompilationUnit(); + int offset = context.getInvocationOffset(); + SelectionFinder finder = new SelectionFinder(cu, offset); + + if (finder.getMemberName() == null) { + return defaultProposals; + } + + List customProposals = new ArrayList(); + for (String name : ruleNames) { + String s = '"' + name + '"'; + CompletionProposal proposal = new CompletionProposal(s, offset, 0, s.length()); + customProposals.add(proposal); + } + + customProposals.addAll(defaultProposals); + return customProposals; + } + + private static List readClassnames(String rulesFolder) { + List classnames = new ArrayList(); + for (File rule : (new File(rulesFolder)).listFiles()) { + if (rule.isDirectory()) { + classnames.addAll(readClassnames(rule.getAbsolutePath())); + continue; + } + + String classname = null; + try { + classname = readClassnameFromRule(rule); + } catch (IOException e) { + Activator.getDefault().logError(e); + } + + if (classname != null) { + classnames.add(classname); + } + } + + return classnames; + } + + private static String readClassnameFromRule(File ruleFile) throws IOException { + final String fileName = ruleFile.getName(); + if (!fileName.endsWith(Constants.cryslFileEnding)) { + return null; + } + + BufferedReader reader = null; + String classname = null; + try { + reader = new BufferedReader(new FileReader(ruleFile)); + String spec = reader.readLine(); + classname = spec.split(" ")[1]; + } finally { + reader.close(); + } + + return classname; + } +} diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/ui/contentassist/SelectionFinder.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/ui/contentassist/SelectionFinder.java new file mode 100644 index 000000000..351a19fb1 --- /dev/null +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/ui/contentassist/SelectionFinder.java @@ -0,0 +1,60 @@ +package de.cognicrypt.codegenerator.ui.contentassist; + +import org.eclipse.core.runtime.NullProgressMonitor; +import org.eclipse.jdt.core.ICompilationUnit; +import org.eclipse.jdt.core.dom.AST; +import org.eclipse.jdt.core.dom.ASTNode; +import org.eclipse.jdt.core.dom.ASTParser; +import org.eclipse.jdt.core.dom.ASTVisitor; +import org.eclipse.jdt.core.dom.MethodInvocation; + +public class SelectionFinder extends ASTVisitor { + private ICompilationUnit unit; + private int offset; + private String memberName; + + public SelectionFinder(ICompilationUnit unit, int offset) { + this.unit = unit; + this.offset = offset; + } + + public String getMemberName() { + visit(); + return memberName; + } + + private boolean visited = false; + + private void visit() { + if (visited) { + return; + } + visited = true; + + ASTParser parser = ASTParser.newParser(AST.JLS12); + parser.setSource(unit); + parser.setSourceRange(offset, -1); + ASTNode node = parser.createAST(new NullProgressMonitor()); + node.accept(this); + } + + @Override + public boolean visit(MethodInvocation node) { + return treatMethodName(node); + } + + private boolean treatMethodName(MethodInvocation node) { + String methodName = node.getName().getFullyQualifiedName(); + int currentOffset = node.getLength() + node.getStartPosition() - 1; + if(("includeClass").equals(methodName) && currentOffset == offset) { + this.memberName = methodName; + return true; + } else if ((node.getExpression() instanceof MethodInvocation)) { + return treatMethodName((MethodInvocation) node.getExpression()); + } else { + return false; + } + } + + +} diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/AltConfigWizard.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/AltConfigWizard.java index 7d8665ba0..1b598d752 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/AltConfigWizard.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/AltConfigWizard.java @@ -11,7 +11,6 @@ package de.cognicrypt.codegenerator.wizard; import java.io.File; -import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; import java.nio.file.StandardCopyOption; @@ -138,10 +137,7 @@ public IWizardPage getNextPage(final IWizardPage currentPage) { } else { CodeGenerators generator = selectedTask.getCodeGen(); if (generator == CodeGenerators.CrySL) { - String selectedTemplate = selectedTask.getCodeTemplate(); - for (Answer resp : this.constraints.values()) { - selectedTemplate += resp.getOption(); - } + String selectedTemplate = constructTemplateName(); selectedTask.setCodeTemplate(selectedTemplate); return addLocatorPage(); } else if (generator == CodeGenerators.XSL) { @@ -159,7 +155,23 @@ public IWizardPage getNextPage(final IWizardPage currentPage) { } return currentPage; } - + + public String constructTemplateName() { + String selectedTemplate = selectedTask.getCodeTemplate(); + for (Answer resp : this.constraints.values()) { + selectedTemplate += resp.getOption(); + } + return selectedTemplate; + } + + public void addConstraints(HashMap constraint) { + this.constraints.putAll(constraint); + } + + public void setSelectedTask(Task selectedTask) { + this.selectedTask = selectedTask; + } + private IWizardPage addLocatorPage() { final LocatorPage locatorPage = new LocatorPage("Locator"); addPage(locatorPage); @@ -272,13 +284,12 @@ public boolean performFinish() { try { codeGenerator.getDeveloperProject().refresh(); } catch (CoreException e1) { - Activator.getDefault().logError(e1); + Activator.getDefault().logError(e1, Constants.CodeGenerationErrorMessage); } } catch (Exception ex) { - Activator.getDefault().logError(ex); + Activator.getDefault().logError(ex, Constants.CodeGenerationErrorMessage); } finally { - waitingDialog.setVisible(false); waitingDialog.dispose(); } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/Configuration.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/Configuration.java index 5469c2a07..1a45b3d46 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/Configuration.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/Configuration.java @@ -21,7 +21,7 @@ import de.cognicrypt.codegenerator.question.Answer; import de.cognicrypt.codegenerator.question.Question; -import de.cognicrypt.utils.FileHelper; +import de.cognicrypt.utils.FileUtils; /** * This class is a storage for the configuration chosen by the user. @@ -33,6 +33,7 @@ public abstract class Configuration { final protected Map options; final protected String pathOnDisk; + @SuppressWarnings("unchecked") public Configuration(Map constraints, String pathOnDisk) { this.pathOnDisk = pathOnDisk; this.options = (Map) constraints; @@ -57,6 +58,6 @@ public String getPath() { * Deletes config file from hard disk. */ public void deleteConfFromDisk() { - FileHelper.deleteFile(this.pathOnDisk); + FileUtils.deleteFile(this.pathOnDisk); } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/LocatorPage.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/LocatorPage.java index 20cb2936a..efed84cea 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/LocatorPage.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/LocatorPage.java @@ -35,6 +35,8 @@ import org.eclipse.ui.model.WorkbenchLabelProvider; import org.eclipse.ui.part.DrillDownComposite; +import de.cognicrypt.core.Activator; +import de.cognicrypt.core.Constants; import de.cognicrypt.utils.DeveloperProject; import de.cognicrypt.utils.Utils; @@ -139,6 +141,7 @@ private boolean isProperTarget(Object target) { String systemTargetPath = targetFolder.getFullPath().removeFirstSegments(1).toOSString(); return systemTargetPath.startsWith(new DeveloperProject(targetFolder.getProject()).getSourcePath()); } catch (CoreException e) { + Activator.getDefault().logError(e, Constants.CodeGenerationErrorMessage); return false; } } diff --git a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/TaskSelectionPage.java b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/TaskSelectionPage.java index 011ad8c36..3875937a4 100644 --- a/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/TaskSelectionPage.java +++ b/plugins/de.cognicrypt.codegenerator/src/main/java/de/cognicrypt/codegenerator/wizard/TaskSelectionPage.java @@ -108,7 +108,6 @@ public void createControl(final Composite parent) { } public Task getSelectedTask() { - // TODO return task depending on the currently selected use case (via button) return this.selectedTask; } @@ -121,12 +120,12 @@ public void setVisible(final boolean visible) { } private Button createImageButton(final Composite container, final Image startImage, String taskName) { - final Button b = new Button(container, SWT.WRAP | SWT.TOGGLE); + final Button imageButton = new Button(container, SWT.WRAP | SWT.TOGGLE); final Rectangle bounds = startImage.getBounds(); - b.setSize(bounds.width, bounds.height); - b.setImage(startImage); - b.setToolTipText(taskName); - return b; + imageButton.setSize(bounds.width, bounds.height); + imageButton.setImage(startImage); + imageButton.setToolTipText(taskName); + return imageButton; } private Image loadImage(final String image) { @@ -145,10 +144,7 @@ private Image loadImage(final String image) { resolvedURI = FileLocator.resolve(entry).toURI(); } - final File file = new File(resolvedURI); - final InputStream is = new FileInputStream(file); - - return new Image(PlatformUI.getWorkbench().getDisplay(), is); + return new Image(PlatformUI.getWorkbench().getDisplay(), new FileInputStream(new File(resolvedURI))); } catch (final Exception ex) { Activator.getDefault().logError(ex); } @@ -179,15 +175,15 @@ public SelectionButtonListener(final List