From 4060e6ebc01ff74168800aa6075695838ff8ad9a Mon Sep 17 00:00:00 2001
From: Pavel Vojtechovsky
Date: Tue, 15 Nov 2016 20:58:05 +0100
Subject: [PATCH] test CtBodyHolder
---
.../test/ctBodyHolder/CtBodyHolderTest.java | 147 ++++++++++++++++++
.../testclasses/CWBStatementTemplate.java | 22 +++
.../testclasses/ClassWithBodies.java | 29 ++++
3 files changed, 198 insertions(+)
create mode 100644 src/test/java/spoon/test/ctBodyHolder/CtBodyHolderTest.java
create mode 100644 src/test/java/spoon/test/ctBodyHolder/testclasses/CWBStatementTemplate.java
create mode 100644 src/test/java/spoon/test/ctBodyHolder/testclasses/ClassWithBodies.java
diff --git a/src/test/java/spoon/test/ctBodyHolder/CtBodyHolderTest.java b/src/test/java/spoon/test/ctBodyHolder/CtBodyHolderTest.java
new file mode 100644
index 00000000000..615685a3a55
--- /dev/null
+++ b/src/test/java/spoon/test/ctBodyHolder/CtBodyHolderTest.java
@@ -0,0 +1,147 @@
+package spoon.test.ctBodyHolder;
+
+import static org.junit.Assert.*;
+import static spoon.testing.utils.ModelUtils.build;
+
+import org.junit.Test;
+
+import spoon.reflect.code.CtAssignment;
+import spoon.reflect.code.CtBlock;
+import spoon.reflect.code.CtBodyHolder;
+import spoon.reflect.code.CtCatch;
+import spoon.reflect.code.CtFor;
+import spoon.reflect.code.CtLiteral;
+import spoon.reflect.code.CtStatement;
+import spoon.reflect.code.CtTry;
+import spoon.reflect.code.CtWhile;
+import spoon.reflect.declaration.CtClass;
+import spoon.reflect.declaration.CtConstructor;
+import spoon.reflect.declaration.CtMethod;
+import spoon.reflect.declaration.CtType;
+import spoon.reflect.declaration.ParentNotInitializedException;
+import spoon.reflect.factory.Factory;
+import spoon.test.ctBodyHolder.testclasses.CWBStatementTemplate;
+import spoon.test.ctBodyHolder.testclasses.ClassWithBodies;
+
+public class CtBodyHolderTest
+{
+ @Test
+ public void testConstructor() throws Exception {
+ Factory factory = build(ClassWithBodies.class, CWBStatementTemplate.class);
+ CtClass> cwbClass = (CtClass>) factory.Type().get(ClassWithBodies.class);
+ assertEquals(1, cwbClass.getConstructors().size());
+ CtConstructor> constructor = cwbClass.getConstructor();
+ checkCtBody(constructor, "constructor_body", 1);
+ }
+
+ @Test
+ public void testMethod() throws Exception {
+ Factory factory = build(ClassWithBodies.class, CWBStatementTemplate.class);
+ CtClass> cwbClass = (CtClass>) factory.Type().get(ClassWithBodies.class);
+ assertEquals(2, cwbClass.getMethods().size());
+ CtMethod> method = cwbClass.getMethod("method");
+ checkCtBody(method, "method_body", 0);
+ }
+
+ @Test
+ public void testTryCatch() throws Exception {
+ Factory factory = build(ClassWithBodies.class, CWBStatementTemplate.class);
+ CtClass> cwbClass = (CtClass>) factory.Type().get(ClassWithBodies.class);
+ assertEquals(2, cwbClass.getMethods().size());
+ CtMethod> method = cwbClass.getMethod("method2");
+ CtBlock> methodBody = method.getBody();
+ assertTrue(methodBody.getStatement(0) instanceof CtTry);
+ CtTry tryStmnt = (CtTry)methodBody.getStatement(0);
+ checkCtBody(tryStmnt, "try_body", 0);
+ assertEquals(1, tryStmnt.getCatchers().size());
+ assertTrue(tryStmnt.getCatchers().get(0) instanceof CtCatch);
+ checkCtBody(tryStmnt.getCatchers().get(0), "catch_body", 0);
+ }
+
+ @Test
+ public void testForWithStatement() throws Exception {
+ Factory factory = build(ClassWithBodies.class, CWBStatementTemplate.class);
+ CtClass> cwbClass = (CtClass>) factory.Type().get(ClassWithBodies.class);
+ assertEquals(2, cwbClass.getMethods().size());
+ CtMethod> method = cwbClass.getMethod("method2");
+ CtBlock> methodBody = method.getBody();
+ assertTrue(methodBody.getStatement(1) instanceof CtFor);
+ CtFor forStmnt = (CtFor)methodBody.getStatement(1);
+ checkCtBody(forStmnt, "for_statemnt", 0);
+ }
+
+ @Test
+ public void testForWithBlock() throws Exception {
+ Factory factory = build(ClassWithBodies.class, CWBStatementTemplate.class);
+ CtClass> cwbClass = (CtClass>) factory.Type().get(ClassWithBodies.class);
+ assertEquals(2, cwbClass.getMethods().size());
+ CtMethod> method = cwbClass.getMethod("method2");
+ CtBlock> methodBody = method.getBody();
+ assertTrue(methodBody.getStatement(2) instanceof CtFor);
+ CtFor forStmnt = (CtFor)methodBody.getStatement(2);
+ checkCtBody(forStmnt, "for_block", 0);
+ }
+
+ @Test
+ public void testWhileWithBlock() throws Exception {
+ Factory factory = build(ClassWithBodies.class, CWBStatementTemplate.class);
+ CtClass> cwbClass = (CtClass>) factory.Type().get(ClassWithBodies.class);
+ assertEquals(2, cwbClass.getMethods().size());
+ CtMethod> method = cwbClass.getMethod("method2");
+ CtBlock> methodBody = method.getBody();
+ assertTrue(methodBody.getStatement(3) instanceof CtWhile);
+ CtWhile whileStmnt = (CtWhile)methodBody.getStatement(3);
+ checkCtBody(whileStmnt, "while_block", 0);
+ }
+
+ private void checkCtBody(CtBodyHolder p_bodyHolder, String p_constant, int off)
+ {
+ CtStatement body = p_bodyHolder.getBody();
+ assertTrue(body instanceof CtBlock>);
+
+ CtBlock> block = (CtBlock)body;
+ assertEquals(1+off, block.getStatements().size());
+
+ assertTrue(block.getStatement(off) instanceof CtAssignment);
+
+ CtAssignment assignment = block.getStatement(off);
+ assertEquals(p_constant, ((CtLiteral)assignment.getAssignment().partiallyEvaluate()).getValue());
+
+ Factory f = body.getFactory();
+
+ CtStatement newStat = new CWBStatementTemplate("xx").apply(body.getParent(CtType.class));
+ try {
+ newStat.getParent();
+ fail();
+ } catch(ParentNotInitializedException e) {
+ //expected exception
+ }
+ //try to set statement and get CtBlock
+ p_bodyHolder.setBody(newStat);
+ CtBlock newBlock = (CtBlock)p_bodyHolder.getBody();
+ assertSame(p_bodyHolder, newBlock.getParent());
+ assertSame(newBlock, newStat.getParent());
+
+ //try to set CtBlock and get the same CtBlock
+ CtStatement newStat2 = newStat.clone();
+ try {
+ newStat2.getParent();
+ fail();
+ } catch(ParentNotInitializedException e) {
+ //expected exception
+ }
+ CtBlock newBlock2 = f.Code().createCtBlock(newStat2);
+ assertSame(newBlock2, newStat2.getParent());
+ try {
+ newBlock2.getParent();
+ fail();
+ } catch(ParentNotInitializedException e) {
+ //expected exception
+ }
+
+ p_bodyHolder.setBody(newBlock2);
+ assertSame(newBlock2, p_bodyHolder.getBody());
+ assertSame(p_bodyHolder, newBlock2.getParent());
+ assertSame(newBlock2, newStat2.getParent());
+ }
+}
diff --git a/src/test/java/spoon/test/ctBodyHolder/testclasses/CWBStatementTemplate.java b/src/test/java/spoon/test/ctBodyHolder/testclasses/CWBStatementTemplate.java
new file mode 100644
index 00000000000..323d3260af3
--- /dev/null
+++ b/src/test/java/spoon/test/ctBodyHolder/testclasses/CWBStatementTemplate.java
@@ -0,0 +1,22 @@
+package spoon.test.ctBodyHolder.testclasses;
+
+import spoon.template.Parameter;
+import spoon.template.StatementTemplate;
+
+public class CWBStatementTemplate extends StatementTemplate
+{
+ @Parameter
+ String value;
+
+ public CWBStatementTemplate(String val)
+ {
+ value = val;
+ }
+
+ @Override
+ public void statement() throws Throwable
+ {
+ System.out.println(value);
+ }
+
+}
diff --git a/src/test/java/spoon/test/ctBodyHolder/testclasses/ClassWithBodies.java b/src/test/java/spoon/test/ctBodyHolder/testclasses/ClassWithBodies.java
new file mode 100644
index 00000000000..797e099af34
--- /dev/null
+++ b/src/test/java/spoon/test/ctBodyHolder/testclasses/ClassWithBodies.java
@@ -0,0 +1,29 @@
+package spoon.test.ctBodyHolder.testclasses;
+
+public class ClassWithBodies
+{
+ String var;
+
+ public ClassWithBodies()
+ {
+ var = "constructor_body";
+ }
+
+ public void method() {
+ var = "method_body";
+ }
+ public void method2() {
+ try {
+ var = "try_body";
+ } catch(Exception e) {
+ var = "catch_body";
+ }
+ for(int i=0; i<10; i++) var="for_statemnt";
+ for(int i=0; i<10; i++) {
+ var="for_block";
+ }
+ while(1+1>var.length()) {
+ var="while_block";
+ }
+ }
+}