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