[eclipse/xtext#1897] converted test code to java

Signed-off-by: Christian Dietrich <christian.dietrich@itemis.de>
This commit is contained in:
Christian Dietrich 2021-01-22 13:59:03 +01:00
parent 1fff012bd0
commit 06acd3c656
12 changed files with 968 additions and 2387 deletions

View file

@ -0,0 +1,227 @@
/**
* Copyright (c) 2017, 2021 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.importHandling;
import java.util.Collection;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.testlanguages.fileAware.fileAware.PackageDeclaration;
import org.eclipse.xtext.testlanguages.fileAware.ide.tests.FileAwareTestLanguageIdeInjectorProvider;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.google.inject.Inject;
import com.google.inject.Provider;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(FileAwareTestLanguageIdeInjectorProvider.class)
public class FileAwareTestLanguageImportTest {
@Inject
private Provider<ChangeSerializer> serializerProvider;
@Inject
private ImportTestHelper importTestHelper;
@Test
public void testRenameGlobal1() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content1 =
"package pkg1\n" +
"\n" +
"element Foo {\n" +
"}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/file1.fileawaretestlanguage", content1));
String content2 =
"package pkg2\n" +
"\n" +
"import pkg1.Foo\n" +
"\n" +
"element Bar {\n" +
" ref Foo\n" +
"}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/file2.fileawaretestlanguage", content2));
ResourceSet rs = importTestHelper.createResourceSet(fs);
PackageDeclaration model = importTestHelper.contents(rs, "inmemory:/file1.fileawaretestlanguage",
PackageDeclaration.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model, (PackageDeclaration it) -> {
it.setName("newpackage");
});
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> changes = importTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package <8:4|newpackage>\n" +
"\n" +
"element Foo {\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"8 4 \"pkg1\" -> \"newpackage\"\n" +
"-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package pkg2\n" +
"\n" +
"import <21:8|newpackage.Foo>\n" +
"\n" +
"element Bar {\n" +
" ref Foo\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"21 8 \"pkg1.Foo\" -> \"newpackage.Foo\"\n";
importTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testMoveToNewPackage() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content1 =
"package pkg1\n" +
"\n" +
"element Foo {\n" +
"}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/file1.fileawaretestlanguage", content1));
String content2 =
"package pkg1\n" +
"\n" +
"element Bar {\n" +
" ref Foo\n" +
"}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/file2.fileawaretestlanguage", content2));
ResourceSet rs = importTestHelper.createResourceSet(fs);
PackageDeclaration model = importTestHelper.contents(rs, "inmemory:/file1.fileawaretestlanguage",
PackageDeclaration.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model, (PackageDeclaration it) -> {
it.setName("newpackage");
});
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> changes = importTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package <8:4|newpackage>\n" +
"\n" +
"element Foo {\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"8 4 \"pkg1\" -> \"newpackage\"\n" +
"-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package pkg1\n" +
"\n" +
"<14:0|import newpackage.Foo\n" +
"\n" +
">element Bar {\n" +
" ref Foo\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"14 0 \"\" -> \"import newpackage...\"\n";
importTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testMoveIntoLocalPackage() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content1 =
"package other\n" +
"\n" +
"element Foo {\n" +
"}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/file1.fileawaretestlanguage", content1));
String content2 =
"package pkg1\n" +
"\n" +
"import other.Foo\n" +
"\n" +
"element Bar {\n" +
" ref Foo\n" +
"}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/file2.fileawaretestlanguage", content2));
ResourceSet rs = importTestHelper.createResourceSet(fs);
PackageDeclaration model = importTestHelper.contents(rs, "inmemory:/file1.fileawaretestlanguage",
PackageDeclaration.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model, (PackageDeclaration it) -> {
it.setName("pkg1");
});
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> changes = importTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package <8:5|pkg1>\n" +
"\n" +
"element Foo {\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"8 5 \"other\" -> \"pkg1\"\n" +
"-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package pkg1\n" +
"\n" +
"<14:18|>element Bar {\n" +
" ref Foo\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"14 18 \"import other.Foo\\n" +
"\\n" +
"\" -> \"\"\n";
importTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testNestedPackage() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content1 =
"package foo \n" +
"element X {}\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/foo/X.fileawaretestlanguage", content1));
String content2 =
"package foo.bar \n" +
"element Y { ref foo.X }\n";
importTestHelper.operator_add(fs, Pair.of("inmemory:/foo/bar/Y.fileawaretestlanguage", content2));
ResourceSet rs = importTestHelper.createResourceSet(fs);
PackageDeclaration model1 = importTestHelper.contents(rs, "inmemory:/foo/X.fileawaretestlanguage",
PackageDeclaration.class);
PackageDeclaration model2 = importTestHelper.contents(rs, "inmemory:/foo/bar/Y.fileawaretestlanguage",
PackageDeclaration.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model1, (PackageDeclaration it) -> {
it.setName("foo2");
});
serializer.addModification(model2, (PackageDeclaration it) -> {
it.setName("foo2.bar"); // was this way in the original test
it.setName("foo2.bar");
});
Collection<IEmfResourceChange> changes = importTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------- inmemory:/foo/X.fileawaretestlanguage (syntax: <offset|text>) ---------\n" +
"package <8:3|foo2> \n" +
"element X {}\n" +
"--------------------------------------------------------------------------------\n" +
"8 3 \"foo\" -> \"foo2\"\n" +
"------ inmemory:/foo/bar/Y.fileawaretestlanguage (syntax: <offset|text>) -------\n" +
"package <8:7|foo2.bar> \n" +
"<17:0|import foo2.X\n" +
"\n" +
">element Y { ref <33:5|X> }\n" +
"--------------------------------------------------------------------------------\n" +
" 8 7 \"foo.bar\" -> \"foo2.bar\"\n" +
"17 0 \"\" -> \"import foo2.X\\n" +
"\\n" +
"\"\n" +
"33 5 \"foo.X\" -> \"X\"\n";
importTestHelper.operator_tripleEquals(changes, expectation);
}
}

View file

@ -1,209 +0,0 @@
/*******************************************************************************
* Copyright (c) 2017 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package org.eclipse.xtext.ide.tests.importHandling
import com.google.inject.Inject
import com.google.inject.Provider
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.util.InMemoryURIHandler
import org.eclipse.xtext.testlanguages.fileAware.fileAware.PackageDeclaration
import org.eclipse.xtext.testlanguages.fileAware.ide.tests.FileAwareTestLanguageIdeInjectorProvider
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner)
@InjectWith(FileAwareTestLanguageIdeInjectorProvider)
class FileAwareTestLanguageImportTest {
@Inject Provider<ChangeSerializer> serializerProvider
@Inject extension ImportTestHelper
@Test
def void testRenameGlobal1() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.fileawaretestlanguage" -> '''
package pkg1
element Foo {
}
'''
fs += "inmemory:/file2.fileawaretestlanguage" -> '''
package pkg2
import pkg1.Foo
element Bar {
ref Foo
}
'''
val rs = fs.createResourceSet
val model = rs.contents("inmemory:/file1.fileawaretestlanguage", PackageDeclaration)
val serializer = serializerProvider.get()
serializer.addModification(model, [model.name = "newpackage"])
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
serializer.endRecordChangesToTextDocuments === '''
-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------
package <8:4|newpackage>
element Foo {
}
--------------------------------------------------------------------------------
8 4 "pkg1" -> "newpackage"
-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------
package pkg2
import <21:8|newpackage.Foo>
element Bar {
ref Foo
}
--------------------------------------------------------------------------------
21 8 "pkg1.Foo" -> "newpackage.Foo"
'''
}
@Test
def void testMoveToNewPackage() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.fileawaretestlanguage" -> '''
package pkg1
element Foo {
}
'''
fs += "inmemory:/file2.fileawaretestlanguage" -> '''
package pkg1
element Bar {
ref Foo
}
'''
val rs = fs.createResourceSet
val model = rs.contents("inmemory:/file1.fileawaretestlanguage", PackageDeclaration)
val serializer = serializerProvider.get()
serializer.addModification(model, [model.name = "newpackage"])
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
serializer.endRecordChangesToTextDocuments === '''
-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------
package <8:4|newpackage>
element Foo {
}
--------------------------------------------------------------------------------
8 4 "pkg1" -> "newpackage"
-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------
package pkg1
<14:0|import newpackage.Foo
>element Bar {
ref Foo
}
--------------------------------------------------------------------------------
14 0 "" -> "import newpackage..."
'''
}
@Test
def void testMoveIntoLocalPackage() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.fileawaretestlanguage" -> '''
package other
element Foo {
}
'''
fs += "inmemory:/file2.fileawaretestlanguage" -> '''
package pkg1
import other.Foo
element Bar {
ref Foo
}
'''
val rs = fs.createResourceSet
val model = rs.contents("inmemory:/file1.fileawaretestlanguage", PackageDeclaration)
val serializer = serializerProvider.get()
serializer.addModification(model, [model.name = "pkg1"])
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
serializer.endRecordChangesToTextDocuments === '''
-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------
package <8:5|pkg1>
element Foo {
}
--------------------------------------------------------------------------------
8 5 "other" -> "pkg1"
-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------
package pkg1
<14:18|>element Bar {
ref Foo
}
--------------------------------------------------------------------------------
14 18 "import other.Foo\n\n" -> ""
'''
}
@Test
def void testNestedPackage() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/foo/X.fileawaretestlanguage" -> '''
package foo
element X {}
'''
fs += "inmemory:/foo/bar/Y.fileawaretestlanguage" -> '''
package foo.bar
element Y { ref foo.X }
'''
val rs = fs.createResourceSet
val model1 = rs.contents("inmemory:/foo/X.fileawaretestlanguage", PackageDeclaration)
val model2 = rs.contents("inmemory:/foo/bar/Y.fileawaretestlanguage", PackageDeclaration)
val serializer = serializerProvider.get()
serializer.addModification(model1) [
name = "foo2"
]
serializer.addModification(model2) [
model2.name = "foo2.bar"
model2.name = "foo2.bar"
]
serializer.endRecordChangesToTextDocuments === '''
-------- inmemory:/foo/X.fileawaretestlanguage (syntax: <offset|text>) ---------
package <8:3|foo2>
element X {}
--------------------------------------------------------------------------------
8 3 "foo" -> "foo2"
------ inmemory:/foo/bar/Y.fileawaretestlanguage (syntax: <offset|text>) -------
package <8:7|foo2.bar>
<17:0|import foo2.X
>element Y { ref <33:5|X> }
--------------------------------------------------------------------------------
8 7 "foo.bar" -> "foo2.bar"
17 0 "" -> "import foo2.X\n\n"
33 5 "foo.X" -> "X"
'''
}
}

View file

@ -0,0 +1,530 @@
/**
* Copyright (c) 2017, 2021 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.serializer;
import java.util.Collection;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.xtext.ide.serializer.IChangeSerializer;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.ChildWithSubChild;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.ChildWithSubChilds;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.MandatoryValue;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Node;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.PartialSerializationTestLanguageFactory;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.SubChild;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.TwoChildLists;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.TwoChilds;
import org.eclipse.xtext.ide.tests.testlanguage.tests.PartialSerializationTestLanguageInjectorProvider;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.google.inject.Inject;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(PartialSerializationTestLanguageInjectorProvider.class)
public class ChangeSerializerTest {
@Extension
private PartialSerializationTestLanguageFactory fac = PartialSerializationTestLanguageFactory.eINSTANCE;
@Inject
private ChangeSerializerTestHelper changeSerializerTestHelper;
@Test
public void testNoop() {
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
changeSerializerTestHelper.operator_tripleEquals(changes, "");
}
@Test
public void testSimple() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#2 foo"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
MandatoryValue model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl",
MandatoryValue.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.setName("bar");
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#2 <3:3|bar>\n" +
"--------------------------------------------------------------------------------\n" +
"3 3 \"foo\" -> \"bar\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testTwoChildren() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root { foo1; foo2; }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getChildren().get(0).setName("bazz4");
model.getChildren().get(1).setName("bazz5");
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root { <10:4|bazz4>; <16:4|bazz5>; }\n" +
"--------------------------------------------------------------------------------\n" +
"10 4 \"foo1\" -> \"bazz4\"\n" +
"16 4 \"foo2\" -> \"bazz5\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testInsertOneChild() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root { child1 { foo1; } }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
Node newNode = fac.createNode();
newNode.setName("bazz");
model.getChildren().get(0).getChildren().add(newNode);
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root { child1 { foo1; <25:0|bazz; >} }\n" +
"--------------------------------------------------------------------------------\n" +
"25 0 \"\" -> \"bazz; \"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testInsertBeforeComment() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content = "#1 root {\n" +
" /**/ \n" +
" child1;\n" +
"}\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
Node newNode = fac.createNode();
newNode.setName("bazz");
model.getChildren().add(0, newNode);
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root {<9:0| bazz;>\n" +
" /**/ \n" +
" child1;\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"9 0 \"\" -> \" bazz;\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testInsertTwoChild() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root { child1 { foo1; } }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
Node newNode1 = fac.createNode();
newNode1.setName("bazz1");
model.getChildren().get(0).getChildren().add(newNode1);
Node newNode2 = fac.createNode();
newNode2.setName("bazz2");
model.getChildren().get(0).getChildren().add(newNode2);
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root { child1 { foo1; <25:0|bazz1; bazz2; >} }\n" +
"--------------------------------------------------------------------------------\n" +
"25 0 \"\" -> \"bazz1; bazz2; \"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testDeleteChild() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root { child1 { foo1; } }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
EcoreUtil.remove(model.getChildren().get(0).getChildren().get(0));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root { child1 { <19:5|> } }\n" +
"--------------------------------------------------------------------------------\n" +
"19 5 \"foo1;\" -> \"\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testDeleteTwoChildren() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root { child1; child2; }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
EcoreUtil.remove(model.getChildren().get(1));
EcoreUtil.remove(model.getChildren().get(0));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root { <10:7|> <18:7|> }\n" +
"--------------------------------------------------------------------------------\n" +
"10 7 \"child1;\" -> \"\"\n" +
"18 7 \"child2;\" -> \"\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testRenameLocal() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs,
Pair.of("inmemory:/file1.pstl", "#1 root { foo1; foo2 { ref foo1 } }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getChildren().get(0).setName("bazz4");
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root { <10:4|bazz4>; foo2 { ref <27:4|bazz4> } }\n" +
"--------------------------------------------------------------------------------\n" +
"10 4 \"foo1\" -> \"bazz4\"\n" +
"27 4 \"foo1\" -> \"bazz4\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testRenameGlobal1() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root1;"));
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file2.pstl", "#1 root2 { ref root1 }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.setName("newroot");
});
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 <3:5|newroot>;\n" +
"--------------------------------------------------------------------------------\n" +
"3 5 \"root1\" -> \"newroot\"\n" +
"----------------- inmemory:/file2.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root2 { ref <15:5|newroot> }\n" +
"--------------------------------------------------------------------------------\n" +
"15 5 \"root1\" -> \"newroot\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testRenameFqn1() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content =
"#1 r {\n" +
" X refs a1.a2 X.a1.a2 r.X.a1.a2 { a1 { a2 refs a2 { a3 { ref a3 } } } }\n" +
" Y refs b1.b2 Y.b1.b2 r.Y.b1.b2 { b1 { b2 { ref b2 } } }\n" +
"}\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
Node node = model.getChildren().get(0).getChildren().get(0).getChildren().get(0);
node.setName("b");
});
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 r {\n" +
" X refs <15:5|a1.b> <21:7|a1.b> <29:9|a1.b> { a1 { <46:2|b> refs <54:2|b> { a3 { ref a3 } } } }\n" +
" Y refs b1.b2 Y.b1.b2 r.Y.b1.b2 { b1 { b2 { ref b2 } } }\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"15 5 \"a1.a2\" -> \"a1.b\"\n" +
"21 7 \"X.a1.a2\" -> \"a1.b\"\n" +
"29 9 \"r.X.a1.a2\" -> \"a1.b\"\n" +
"46 2 \"a2\" -> \"b\"\n" +
"54 2 \"a2\" -> \"b\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testRenameFqn1ValueConversion() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content =
"#1 r {\n" +
" X refs ^a1.^a2 ^X.^a1.^a2 ^r.^X.^a1.^a2 { a1 { a2 refs ^a2 { a3 { ref ^a3 } } } }\n" +
" Y refs ^b1.^b2 ^Y.^b1.^b2 ^r.^Y.^b1.^b2 { b1 { b2 { ref b2 } } }\n" +
"}\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
Node node = model.getChildren().get(0).getChildren().get(0).getChildren().get(0);
node.setName("b");
});
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 r {\n" +
" X refs <15:7|a1.b> <23:10|a1.b> <34:13|a1.b> { a1 { <55:2|b> refs <63:3|b> { a3 { ref ^a3 } } } }\n" +
" Y refs ^b1.^b2 ^Y.^b1.^b2 ^r.^Y.^b1.^b2 { b1 { b2 { ref b2 } } }\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"15 7 \"^a1.^a2\" -> \"a1.b\"\n" +
"23 10 \"^X.^a1.^a2\" -> \"a1.b\"\n" +
"34 13 \"^r.^X.^a1.^a2\" -> \"a1.b\"\n" +
"55 2 \"a2\" -> \"b\"\n" +
"63 3 \"^a2\" -> \"b\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testResourceURIChange() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/f.pstl", "#1 root { }"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/f.pstl", Node.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.eResource().setURI(URI.createURI("inmemory:/x.pstl"));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----- renamed inmemory:/f.pstl to inmemory:/x.pstl (syntax: <offset|text>) -----\n" +
"(no changes)\n" +
"--------------------------------------------------------------------------------\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testAddChildElement() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content =
"#22 {\n" +
" child1\n" +
" children1 {\n" +
" child2 child3\n" +
" }\n" +
"}";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file-move.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
TwoChildLists model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file-move.pstl",
TwoChildLists.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
MandatoryValue newMandatoryValue = fac.createMandatoryValue();
newMandatoryValue.setName("newChild");
model.getDirectChildren().add(newMandatoryValue);
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"--------------- inmemory:/file-move.pstl (syntax: <offset|text>) ---------------\n" +
"#22 {\n" +
" child1<13:0| newChild>\n" +
" children1 {\n" +
" child2 child3\n" +
" }\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"13 0 \"\" -> \" newChild\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testMoveElement() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content =
"#22 {\n" +
" child1\n" +
" children1 {\n" +
" child2 jumper\n" +
" }\n" +
"}";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file-move1.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
TwoChildLists model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file-move1.pstl",
TwoChildLists.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getDirectChildren().add(IterableExtensions.findFirst(model.getChildsList().getChildren(),
(MandatoryValue v) -> "jumper".equals(v.getName())));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------------- inmemory:/file-move1.pstl (syntax: <offset|text>) ---------------\n" +
"#22 {\n" +
" child1<13:0| jumper>\n" +
" children1 {\n" +
" child2 <36:6|>\n" +
" }\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"13 0 \"\" -> \" jumper\"\n" +
"36 6 \"jumper\" -> \"\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testMoveElement_2() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content =
"#22 {\n" +
" child1\n" +
" children1 {\n" +
" child2 jumper\n" +
" }\n" +
"}";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file-move.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
TwoChildLists model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file-move.pstl",
TwoChildLists.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getDirectChildren().add(0, IterableExtensions.findFirst(model.getChildsList().getChildren(),
(MandatoryValue v) -> "jumper".equals(v.getName())));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"--------------- inmemory:/file-move.pstl (syntax: <offset|text>) ---------------\n" +
"#22 {<5:0| jumper>\n" +
" child1\n" +
" children1 {\n" +
" child2 <36:6|>\n" +
" }\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
" 5 0 \"\" -> \" jumper\"\n" +
"36 6 \"jumper\" -> \"\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testMoveElement_2a() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content = "#22 {\n" +
" child1 child3\n" +
" children1 {\n" +
" child2 jumper\n" +
" }\n" +
"}";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file-move2a.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
TwoChildLists model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file-move2a.pstl",
TwoChildLists.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getDirectChildren().add(1, IterableExtensions.findFirst(model.getChildsList().getChildren(),
(MandatoryValue v) -> "jumper".equals(v.getName())));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------------- inmemory:/file-move2a.pstl (syntax: <offset|text>) --------------\n" +
"#22 {\n" +
" child1 <14:0|jumper >child3\n" +
" children1 {\n" +
" child2 <43:6|>\n" +
" }\n" +
"}\n" +
"--------------------------------------------------------------------------------\n" +
"14 0 \"\" -> \"jumper \"\n" +
"43 6 \"jumper\" -> \"\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testMoveElement_3() {
InMemoryURIHandler fs = new InMemoryURIHandler();
String content = "#24 direct:\n" +
" child:jumper\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file-move3.pstl", content));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
TwoChilds model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file-move3.pstl",
TwoChilds.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
model.setDirectChild(model.getOptChild().getChild());
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"-------------- inmemory:/file-move3.pstl (syntax: <offset|text>) ---------------\n" +
"<0:26|#24 direct:\n" +
" jumper\n" +
"child :>\n" +
"--------------------------------------------------------------------------------\n" +
"0 26 \"#24 direct:\\n" +
" chil...\" -> \"#24 direct:\\n" +
" jump...\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testAddElements() {
String uri = "inmemory:/file-add.pstl";
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of(uri, "#23"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
ChildWithSubChilds model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, uri, ChildWithSubChilds.class);
IChangeSerializer serializer = changeSerializerTestHelper.newChangeSerializer();
serializer.addModification(model.eResource(), (Resource it) -> {
ChildWithSubChild newChildWithSubChild = fac.createChildWithSubChild();
SubChild newSubChild1 = fac.createSubChild();
newSubChild1.setName("A");
newChildWithSubChild.getSubChilds().add(newSubChild1);
model.getChildren().add(newChildWithSubChild);
SubChild newSubChild = fac.createSubChild();
newSubChild.setName("A2");
model.getChildren().get(0).getSubChilds().add(newSubChild);
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"--------------- inmemory:/file-add.pstl (syntax: <offset|text>) ----------------\n" +
"<0:3|#23 subs A A2>\n" +
"--------------------------------------------------------------------------------\n" +
"0 3 \"#23\" -> \"#23 subs A A2\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
}

View file

@ -1,507 +0,0 @@
/*******************************************************************************
* Copyright (c) 2017 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package org.eclipse.xtext.ide.tests.serializer
import com.google.inject.Inject
import org.eclipse.emf.ecore.util.EcoreUtil
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.MandatoryValue
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Node
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.PartialSerializationTestLanguageFactory
import org.eclipse.xtext.ide.tests.testlanguage.tests.PartialSerializationTestLanguageInjectorProvider
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.util.InMemoryURIHandler
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.TwoChildLists
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.ChildWithSubChilds
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.TwoChilds
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner)
@InjectWith(PartialSerializationTestLanguageInjectorProvider)
class ChangeSerializerTest {
extension PartialSerializationTestLanguageFactory fac = PartialSerializationTestLanguageFactory.eINSTANCE
@Inject extension ChangeSerializerTestHelper
@Test
def void testNoop() {
val serializer = newChangeSerializer()
serializer.endRecordChangesToTextDocuments === ""
}
@Test
def void testSimple() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#2 foo'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", MandatoryValue)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.name = "bar"
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#2 <3:3|bar>
--------------------------------------------------------------------------------
3 3 "foo" -> "bar"
'''
}
@Test
def void testTwoChildren() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root { foo1; foo2; }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.get(0).name = "bazz4"
model.children.get(1).name = "bazz5"
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root { <10:4|bazz4>; <16:4|bazz5>; }
--------------------------------------------------------------------------------
10 4 "foo1" -> "bazz4"
16 4 "foo2" -> "bazz5"
'''
}
@Test
def void testInsertOneChild() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root { child1 { foo1; } }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.get(0).children += createNode => [name = "bazz"]
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root { child1 { foo1; <25:0|bazz; >} }
--------------------------------------------------------------------------------
25 0 "" -> "bazz; "
'''
}
@Test
def void testInsertBeforeComment() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''
#1 root {
/**/
child1;
}
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.add(0, createNode => [name = "bazz"])
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root {<9:0| bazz;>
/**/
child1;
}
--------------------------------------------------------------------------------
9 0 "" -> " bazz;"
'''
}
@Test
def void testInsertTwoChild() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root { child1 { foo1; } }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.get(0).children += createNode => [name = "bazz1"]
model.children.get(0).children += createNode => [name = "bazz2"]
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root { child1 { foo1; <25:0|bazz1; bazz2; >} }
--------------------------------------------------------------------------------
25 0 "" -> "bazz1; bazz2; "
'''
}
@Test
def void testDeleteChild() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root { child1 { foo1; } }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
EcoreUtil.remove(model.children.get(0).children.get(0))
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root { child1 { <19:5|> } }
--------------------------------------------------------------------------------
19 5 "foo1;" -> ""
'''
}
@Test
def void testDeleteTwoChildren() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root { child1; child2; }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
EcoreUtil.remove(model.children.get(1))
EcoreUtil.remove(model.children.get(0))
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root { <10:7|> <18:7|> }
--------------------------------------------------------------------------------
10 7 "child1;" -> ""
18 7 "child2;" -> ""
'''
}
@Test
def void testRenameLocal() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root { foo1; foo2 { ref foo1 } }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.get(0).name = "bazz4"
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root { <10:4|bazz4>; foo2 { ref <27:4|bazz4> } }
--------------------------------------------------------------------------------
10 4 "foo1" -> "bazz4"
27 4 "foo1" -> "bazz4"
'''
}
@Test
def void testRenameGlobal1() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root1;'''
fs += "inmemory:/file2.pstl" -> '''#1 root2 { ref root1 }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.name = "newroot"
]
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 <3:5|newroot>;
--------------------------------------------------------------------------------
3 5 "root1" -> "newroot"
----------------- inmemory:/file2.pstl (syntax: <offset|text>) -----------------
#1 root2 { ref <15:5|newroot> }
--------------------------------------------------------------------------------
15 5 "root1" -> "newroot"
'''
}
@Test
def void testRenameFqn1() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''
#1 r {
X refs a1.a2 X.a1.a2 r.X.a1.a2 { a1 { a2 refs a2 { a3 { ref a3 } } } }
Y refs b1.b2 Y.b1.b2 r.Y.b1.b2 { b1 { b2 { ref b2 } } }
}
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.head.children.head.children.head.name = "b"
]
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 r {
X refs <15:5|a1.b> <21:7|a1.b> <29:9|a1.b> { a1 { <46:2|b> refs <54:2|b> { a3 { ref a3 } } } }
Y refs b1.b2 Y.b1.b2 r.Y.b1.b2 { b1 { b2 { ref b2 } } }
}
--------------------------------------------------------------------------------
15 5 "a1.a2" -> "a1.b"
21 7 "X.a1.a2" -> "a1.b"
29 9 "r.X.a1.a2" -> "a1.b"
46 2 "a2" -> "b"
54 2 "a2" -> "b"
'''
}
@Test
def void testRenameFqn1ValueConversion() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''
#1 r {
X refs ^a1.^a2 ^X.^a1.^a2 ^r.^X.^a1.^a2 { a1 { a2 refs ^a2 { a3 { ref ^a3 } } } }
Y refs ^b1.^b2 ^Y.^b1.^b2 ^r.^Y.^b1.^b2 { b1 { b2 { ref b2 } } }
}
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children.head.children.head.children.head.name = "b"
]
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 r {
X refs <15:7|a1.b> <23:10|a1.b> <34:13|a1.b> { a1 { <55:2|b> refs <63:3|b> { a3 { ref ^a3 } } } }
Y refs ^b1.^b2 ^Y.^b1.^b2 ^r.^Y.^b1.^b2 { b1 { b2 { ref b2 } } }
}
--------------------------------------------------------------------------------
15 7 "^a1.^a2" -> "a1.b"
23 10 "^X.^a1.^a2" -> "a1.b"
34 13 "^r.^X.^a1.^a2" -> "a1.b"
55 2 "a2" -> "b"
63 3 "^a2" -> "b"
'''
}
@Test
def void testResourceURIChange() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/f.pstl" -> '''#1 root { }'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/f.pstl", Node)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.eResource.URI = org.eclipse.emf.common.util.URI.createURI("inmemory:/x.pstl")
]
serializer.endRecordChangesToTextDocuments === '''
----- renamed inmemory:/f.pstl to inmemory:/x.pstl (syntax: <offset|text>) -----
(no changes)
--------------------------------------------------------------------------------
'''
}
@Test
def void testAddChildElement() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file-move.pstl" -> '''
#22 {
child1
children1 {
child2 child3
}
}'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file-move.pstl", TwoChildLists)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.directChildren.add(createMandatoryValue => [name = "newChild"])
]
serializer.endRecordChangesToTextDocuments === '''
--------------- inmemory:/file-move.pstl (syntax: <offset|text>) ---------------
#22 {
child1<13:0| newChild>
children1 {
child2 child3
}
}
--------------------------------------------------------------------------------
13 0 "" -> " newChild"
'''
}
@Test
def void testMoveElement() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file-move1.pstl" -> '''
#22 {
child1
children1 {
child2 jumper
}
}'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file-move1.pstl", TwoChildLists)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.directChildren.add(model.childsList.children.findFirst[name == "jumper"])
]
serializer.endRecordChangesToTextDocuments === '''
-------------- inmemory:/file-move1.pstl (syntax: <offset|text>) ---------------
#22 {
child1<13:0| jumper>
children1 {
child2 <36:6|>
}
}
--------------------------------------------------------------------------------
13 0 "" -> " jumper"
36 6 "jumper" -> ""
'''
}
@Test
def void testMoveElement_2() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file-move.pstl" -> '''
#22 {
child1
children1 {
child2 jumper
}
}'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file-move.pstl", TwoChildLists)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.directChildren.add(0, model.childsList.children.findFirst[name == "jumper"])
]
serializer.endRecordChangesToTextDocuments === '''
--------------- inmemory:/file-move.pstl (syntax: <offset|text>) ---------------
#22 {<5:0| jumper>
child1
children1 {
child2 <36:6|>
}
}
--------------------------------------------------------------------------------
5 0 "" -> " jumper"
36 6 "jumper" -> ""
'''
}
@Test
def void testMoveElement_2a() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file-move2a.pstl" -> '''
#22 {
child1 child3
children1 {
child2 jumper
}
}'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file-move2a.pstl", TwoChildLists)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.directChildren.add(1, model.childsList.children.findFirst[name == "jumper"])
]
serializer.endRecordChangesToTextDocuments === '''
-------------- inmemory:/file-move2a.pstl (syntax: <offset|text>) --------------
#22 {
child1 <14:0|jumper >child3
children1 {
child2 <43:6|>
}
}
--------------------------------------------------------------------------------
14 0 "" -> "jumper "
43 6 "jumper" -> ""
'''
}
@Test
def void testMoveElement_3() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file-move3.pstl" -> '''
#24 direct:
child:jumper
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file-move3.pstl", TwoChilds)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.directChild = model.optChild.child
]
serializer.endRecordChangesToTextDocuments === '''
-------------- inmemory:/file-move3.pstl (syntax: <offset|text>) ---------------
<0:26|#24 direct:
jumper
child :>
--------------------------------------------------------------------------------
0 26 "#24 direct:\n chil..." -> "#24 direct:\n jump..."
'''
}
@Test
def void testAddElements() {
val uri = "inmemory:/file-add.pstl"
val fs = new InMemoryURIHandler()
fs += uri -> '''
#23'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile(uri, ChildWithSubChilds)
val serializer = newChangeSerializer()
serializer.addModification(model.eResource) [
model.children += createChildWithSubChild => [subChilds += createSubChild => [name = "A"]]
model.children.head => [subChilds += createSubChild => [name = "A2"]]
]
serializer.endRecordChangesToTextDocuments === '''
--------------- inmemory:/file-add.pstl (syntax: <offset|text>) ----------------
<0:3|#23 subs A A2>
--------------------------------------------------------------------------------
0 3 "#23" -> "#23 subs A A2"
'''
}
}

View file

@ -0,0 +1,144 @@
/**
* Copyright (c) 2017, 2021 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.serializer;
import java.util.Collection;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.EClassRef;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Model;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.google.inject.Inject;
import com.google.inject.Provider;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(PartialSerializationTestLanguageInjectorProviderWithEmf.class)
public class ChangeSerializerWithEmfTest {
@Inject
private Provider<ChangeSerializer> serializerProvider;
@Inject
private ChangeSerializerTestHelper changeSerializerTestHelper;
@Test
public void testChangeRefToXML() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#21 MyPackage.MyClass1"));
String ecore =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
" xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">\n" +
" <eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\" eSuperTypes=\"#//MyClass2\"/>\n" +
" <eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass2\"/>\n" +
"</ecore:EPackage>\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file2.ecore", ecore));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
EClassRef model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl",
EClassRef.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model, (EClassRef it) -> {
model.setRef(((EClass) model.getRef().getEPackage().getEClassifiers().get(1)));
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#21 <4:18|MyPackage.MyClass2>\n" +
"--------------------------------------------------------------------------------\n" +
"4 18 \"MyPackage.MyClass1\" -> \"MyPackage.MyClass2\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testChangeInXML() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#21 MyPackage.MyClass1"));
String ecore =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
" xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">\n" +
" <eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\"/>\n" +
"</ecore:EPackage>\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file2.ecore", ecore));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
EPackage model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file2.ecore",
EPackage.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model, (EPackage it) -> {
((EClass) model.getEClassifiers().get(0)).setName("NewClass");
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"---------------------------- inmemory:/file2.ecore -----------------------------\n" +
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
" xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">\n" +
" <eClassifiers xsi:type=\"ecore:EClass\" name=\"NewClass\"/>\n" +
"</ecore:EPackage>\n" +
"--------------------------------------------------------------------------------\n" +
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#21 <4:18|MyPackage.NewClass>\n" +
"--------------------------------------------------------------------------------\n" +
"4 18 \"MyPackage.MyClass1\" -> \"MyPackage.NewClass\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
@Test
public void testChangeInDSL() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#20 DslEClass"));
String ecore =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
" xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">\n" +
" <eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\" eSuperTypes=\"inmemory:/file1.pstl#//@clazz.0\"/>\n" +
"</ecore:EPackage>\n";
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file2.ecore", ecore));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Model model = changeSerializerTestHelper.findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Model.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getClazz().get(0).setName("ChangedName");
EClass newEClass = EcoreFactory.eINSTANCE.createEClass();
newEClass.setName("NewName");
model.getClazz().add(0, newEClass);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#20 <4:0|NewName ><4:9| ChangedName>\n" +
"--------------------------------------------------------------------------------\n" +
"4 0 \"\" -> \"NewName \"\n" +
"4 9 \"DslEClass\" -> \" ChangedName\"\n" +
"---------------------------- inmemory:/file2.ecore -----------------------------\n" +
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n" +
" xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">\n" +
" <eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\" eSuperTypes=\"file1.pstl#//@clazz.1\"/>\n" +
"</ecore:EPackage>\n" +
"--------------------------------------------------------------------------------\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
}

View file

@ -1,136 +0,0 @@
/*******************************************************************************
* Copyright (c) 2017, 2020 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package org.eclipse.xtext.ide.tests.serializer
import com.google.inject.Inject
import com.google.inject.Provider
import org.eclipse.emf.ecore.EClass
import org.eclipse.emf.ecore.EPackage
import org.eclipse.emf.ecore.EcoreFactory
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.EClassRef
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Model
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.util.InMemoryURIHandler
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner)
@InjectWith(PartialSerializationTestLanguageInjectorProviderWithEmf)
class ChangeSerializerWithEmfTest {
@Inject Provider<ChangeSerializer> serializerProvider
@Inject extension ChangeSerializerTestHelper
@Test
def void testChangeRefToXML() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#21 MyPackage.MyClass1'''
fs += "inmemory:/file2.ecore" -> '''
<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="MyPackage">
<eClassifiers xsi:type="ecore:EClass" name="MyClass1" eSuperTypes="#//MyClass2"/>
<eClassifiers xsi:type="ecore:EClass" name="MyClass2"/>
</ecore:EPackage>
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", EClassRef)
val serializer = serializerProvider.get()
serializer.addModification(model) [
model.ref = model.ref.EPackage.EClassifiers.get(1) as EClass
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#21 <4:18|MyPackage.MyClass2>
--------------------------------------------------------------------------------
4 18 "MyPackage.MyClass1" -> "MyPackage.MyClass2"
'''
}
@Test
def void testChangeInXML() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#21 MyPackage.MyClass1'''
fs += "inmemory:/file2.ecore" -> '''
<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="MyPackage">
<eClassifiers xsi:type="ecore:EClass" name="MyClass1"/>
</ecore:EPackage>
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file2.ecore", EPackage)
val serializer = serializerProvider.get()
serializer.addModification(model) [
(model.EClassifiers.head as EClass).name = "NewClass"
]
serializer.endRecordChangesToTextDocuments === '''
---------------------------- inmemory:/file2.ecore -----------------------------
<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="MyPackage">
<eClassifiers xsi:type="ecore:EClass" name="NewClass"/>
</ecore:EPackage>
--------------------------------------------------------------------------------
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#21 <4:18|MyPackage.NewClass>
--------------------------------------------------------------------------------
4 18 "MyPackage.MyClass1" -> "MyPackage.NewClass"
'''
}
@Test
def void testChangeInDSL() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#20 DslEClass'''
fs += "inmemory:/file2.ecore" -> '''
<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="MyPackage">
<eClassifiers xsi:type="ecore:EClass" name="MyClass1" eSuperTypes="inmemory:/file1.pstl#//@clazz.0"/>
</ecore:EPackage>
'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Model)
val serializer = serializerProvider.get()
serializer.addModification(model.eResource) [
model.clazz.get(0).name = "ChangedName"
model.clazz.add(0, EcoreFactory.eINSTANCE.createEClass => [name = "NewName"])
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#20 <4:0|NewName ><4:9| ChangedName>
--------------------------------------------------------------------------------
4 0 "" -> "NewName "
4 9 "DslEClass" -> " ChangedName"
---------------------------- inmemory:/file2.ecore -----------------------------
<?xml version="1.0" encoding="UTF-8"?>
<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="MyPackage">
<eClassifiers xsi:type="ecore:EClass" name="MyClass1" eSuperTypes="file1.pstl#//@clazz.1"/>
</ecore:EPackage>
--------------------------------------------------------------------------------
'''
}
}

View file

@ -0,0 +1,67 @@
/**
* Copyright (c) 2017, 2021 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.serializer;
import java.util.Collection;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Node;
import org.eclipse.xtext.ide.tests.testlanguage.tests.PartialSerializationTestLanguageInjectorProvider;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import com.google.inject.Inject;
import com.google.inject.Provider;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(PartialSerializationTestLanguageInjectorProvider.class)
public class ChangeSerializerWithImports {
@Inject
private Provider<ChangeSerializer> serializerProvider;
@Inject
private ChangeSerializerTestHelper changeSerializerTestHelper;
@Test
public void testRenameGlobal1() {
InMemoryURIHandler fs = new InMemoryURIHandler();
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file1.pstl", "#1 root1 { child1; }"));
changeSerializerTestHelper.operator_add(fs, Pair.of("inmemory:/file2.pstl", "#1 import root1.child1 refs child1;"));
ResourceSet rs = changeSerializerTestHelper.createResourceSet(fs);
Node model = changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
ChangeSerializer serializer = serializerProvider.get();
serializer.addModification(model.eResource(), (Resource it) -> {
model.getChildren().get(0).setName("newchild");
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
});
Collection<IEmfResourceChange> changes = changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
String expectation =
"----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------\n" +
"#1 root1 { <11:6|newchild>; }\n" +
"--------------------------------------------------------------------------------\n" +
"11 6 \"child1\" -> \"newchild\"\n" +
"----------------- inmemory:/file2.pstl (syntax: <offset|text>) -----------------\n" +
"#1 import <10:12|root1.newchild> refs <28:6|newchild>;\n" +
"--------------------------------------------------------------------------------\n" +
"10 12 \"root1.child1\" -> \"root1.newchild\"\n" +
"28 6 \"child1\" -> \"newchild\"\n";
changeSerializerTestHelper.operator_tripleEquals(changes, expectation);
}
}

View file

@ -1,61 +0,0 @@
/*******************************************************************************
* Copyright (c) 2017 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package org.eclipse.xtext.ide.tests.serializer
import com.google.inject.Inject
import com.google.inject.Provider
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Node
import org.eclipse.xtext.ide.tests.testlanguage.tests.PartialSerializationTestLanguageInjectorProvider
import org.eclipse.xtext.testing.InjectWith
import org.eclipse.xtext.testing.XtextRunner
import org.eclipse.xtext.testing.util.InMemoryURIHandler
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner)
@InjectWith(PartialSerializationTestLanguageInjectorProvider)
class ChangeSerializerWithImports {
@Inject Provider<ChangeSerializer> serializerProvider
@Inject extension ChangeSerializerTestHelper
@Test
def void testRenameGlobal1() {
val fs = new InMemoryURIHandler()
fs += "inmemory:/file1.pstl" -> '''#1 root1 { child1; }'''
fs += "inmemory:/file2.pstl" -> '''#1 import root1.child1 refs child1;'''
val rs = fs.createResourceSet
val model = rs.findFirstOfTypeInFile("inmemory:/file1.pstl", Node)
val serializer = serializerProvider.get()
serializer.addModification(model.eResource) [
model.children.get(0).name = "newchild"
Assert.assertEquals(1, model.eResource.resourceSet.resources.size)
]
serializer.endRecordChangesToTextDocuments === '''
----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------
#1 root1 { <11:6|newchild>; }
--------------------------------------------------------------------------------
11 6 "child1" -> "newchild"
----------------- inmemory:/file2.pstl (syntax: <offset|text>) -----------------
#1 import <10:12|root1.newchild> refs <28:6|newchild>;
--------------------------------------------------------------------------------
10 12 "root1.child1" -> "root1.newchild"
28 6 "child1" -> "newchild"
'''
}
}

View file

@ -1,322 +0,0 @@
/**
* Copyright (c) 2017 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.importHandling;
import com.google.inject.Inject;
import com.google.inject.Provider;
import java.util.Collection;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.ide.serializer.IChangeSerializer;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.testlanguages.fileAware.fileAware.PackageDeclaration;
import org.eclipse.xtext.testlanguages.fileAware.ide.tests.FileAwareTestLanguageIdeInjectorProvider;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(FileAwareTestLanguageIdeInjectorProvider.class)
@SuppressWarnings("all")
public class FileAwareTestLanguageImportTest {
@Inject
private Provider<ChangeSerializer> serializerProvider;
@Inject
@Extension
private ImportTestHelper _importTestHelper;
@Test
public void testRenameGlobal1() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("package pkg1");
_builder.newLine();
_builder.newLine();
_builder.append("element Foo {");
_builder.newLine();
_builder.append("}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.fileawaretestlanguage", _builder.toString());
this._importTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("package pkg2");
_builder_1.newLine();
_builder_1.newLine();
_builder_1.append("import pkg1.Foo");
_builder_1.newLine();
_builder_1.newLine();
_builder_1.append("element Bar {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("ref Foo");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.fileawaretestlanguage", _builder_1.toString());
this._importTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._importTestHelper.createResourceSet(fs);
final PackageDeclaration model = this._importTestHelper.<PackageDeclaration>contents(rs, "inmemory:/file1.fileawaretestlanguage", PackageDeclaration.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<PackageDeclaration> _function = (PackageDeclaration it) -> {
model.setName("newpackage");
};
serializer.<PackageDeclaration>addModification(model, _function);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._importTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package <8:4|newpackage>");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("element Foo {");
_builder_2.newLine();
_builder_2.append("}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("8 4 \"pkg1\" -> \"newpackage\"");
_builder_2.newLine();
_builder_2.append("-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package pkg2");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("import <21:8|newpackage.Foo>");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("element Bar {");
_builder_2.newLine();
_builder_2.append("\t");
_builder_2.append("ref Foo");
_builder_2.newLine();
_builder_2.append("}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("21 8 \"pkg1.Foo\" -> \"newpackage.Foo\"");
_builder_2.newLine();
this._importTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
@Test
public void testMoveToNewPackage() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("package pkg1");
_builder.newLine();
_builder.newLine();
_builder.append("element Foo {");
_builder.newLine();
_builder.append("}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.fileawaretestlanguage", _builder.toString());
this._importTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("package pkg1");
_builder_1.newLine();
_builder_1.newLine();
_builder_1.append("element Bar {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("ref Foo");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.fileawaretestlanguage", _builder_1.toString());
this._importTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._importTestHelper.createResourceSet(fs);
final PackageDeclaration model = this._importTestHelper.<PackageDeclaration>contents(rs, "inmemory:/file1.fileawaretestlanguage", PackageDeclaration.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<PackageDeclaration> _function = (PackageDeclaration it) -> {
model.setName("newpackage");
};
serializer.<PackageDeclaration>addModification(model, _function);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._importTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package <8:4|newpackage>");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("element Foo {");
_builder_2.newLine();
_builder_2.append("}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("8 4 \"pkg1\" -> \"newpackage\"");
_builder_2.newLine();
_builder_2.append("-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package pkg1");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("<14:0|import newpackage.Foo");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append(">element Bar {");
_builder_2.newLine();
_builder_2.append("\t");
_builder_2.append("ref Foo");
_builder_2.newLine();
_builder_2.append("}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("14 0 \"\" -> \"import newpackage...\"");
_builder_2.newLine();
this._importTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
@Test
public void testMoveIntoLocalPackage() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("package other");
_builder.newLine();
_builder.newLine();
_builder.append("element Foo {");
_builder.newLine();
_builder.append("}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.fileawaretestlanguage", _builder.toString());
this._importTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("package pkg1");
_builder_1.newLine();
_builder_1.newLine();
_builder_1.append("import other.Foo");
_builder_1.newLine();
_builder_1.newLine();
_builder_1.append("element Bar {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("ref Foo");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.fileawaretestlanguage", _builder_1.toString());
this._importTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._importTestHelper.createResourceSet(fs);
final PackageDeclaration model = this._importTestHelper.<PackageDeclaration>contents(rs, "inmemory:/file1.fileawaretestlanguage", PackageDeclaration.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<PackageDeclaration> _function = (PackageDeclaration it) -> {
model.setName("pkg1");
};
serializer.<PackageDeclaration>addModification(model, _function);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._importTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("-------- inmemory:/file1.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package <8:5|pkg1>");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("element Foo {");
_builder_2.newLine();
_builder_2.append("}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("8 5 \"other\" -> \"pkg1\"");
_builder_2.newLine();
_builder_2.append("-------- inmemory:/file2.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package pkg1");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append("<14:18|>element Bar {");
_builder_2.newLine();
_builder_2.append("\t");
_builder_2.append("ref Foo");
_builder_2.newLine();
_builder_2.append("}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("14 18 \"import other.Foo\\n\\n\" -> \"\"");
_builder_2.newLine();
this._importTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
@Test
public void testNestedPackage() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("package foo ");
_builder.newLine();
_builder.append("element X {}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/foo/X.fileawaretestlanguage", _builder.toString());
this._importTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("package foo.bar ");
_builder_1.newLine();
_builder_1.append("element Y { ref foo.X }");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/foo/bar/Y.fileawaretestlanguage", _builder_1.toString());
this._importTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._importTestHelper.createResourceSet(fs);
final PackageDeclaration model1 = this._importTestHelper.<PackageDeclaration>contents(rs, "inmemory:/foo/X.fileawaretestlanguage", PackageDeclaration.class);
final PackageDeclaration model2 = this._importTestHelper.<PackageDeclaration>contents(rs, "inmemory:/foo/bar/Y.fileawaretestlanguage", PackageDeclaration.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<PackageDeclaration> _function = (PackageDeclaration it) -> {
it.setName("foo2");
};
serializer.<PackageDeclaration>addModification(model1, _function);
final IChangeSerializer.IModification<PackageDeclaration> _function_1 = (PackageDeclaration it) -> {
model2.setName("foo2.bar");
model2.setName("foo2.bar");
};
serializer.<PackageDeclaration>addModification(model2, _function_1);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._importTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("-------- inmemory:/foo/X.fileawaretestlanguage (syntax: <offset|text>) ---------");
_builder_2.newLine();
_builder_2.append("package <8:3|foo2> ");
_builder_2.newLine();
_builder_2.append("element X {}");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("8 3 \"foo\" -> \"foo2\"");
_builder_2.newLine();
_builder_2.append("------ inmemory:/foo/bar/Y.fileawaretestlanguage (syntax: <offset|text>) -------");
_builder_2.newLine();
_builder_2.append("package <8:7|foo2.bar> ");
_builder_2.newLine();
_builder_2.append("<17:0|import foo2.X");
_builder_2.newLine();
_builder_2.newLine();
_builder_2.append(">element Y { ref <33:5|X> }");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append(" ");
_builder_2.append("8 7 \"foo.bar\" -> \"foo2.bar\"");
_builder_2.newLine();
_builder_2.append("17 0 \"\" -> \"import foo2.X\\n\\n\"");
_builder_2.newLine();
_builder_2.append("33 5 \"foo.X\" -> \"X\"");
_builder_2.newLine();
this._importTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
}

View file

@ -1,839 +0,0 @@
/**
* Copyright (c) 2017 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.serializer;
import com.google.common.base.Objects;
import com.google.inject.Inject;
import java.util.Collection;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.ide.serializer.IChangeSerializer;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.ChildWithSubChild;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.ChildWithSubChilds;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.MandatoryValue;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Node;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.PartialSerializationTestLanguageFactory;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.SubChild;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.TwoChildLists;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.TwoChilds;
import org.eclipse.xtext.ide.tests.testlanguage.tests.PartialSerializationTestLanguageInjectorProvider;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Functions.Function1;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ObjectExtensions;
import org.eclipse.xtext.xbase.lib.Pair;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(PartialSerializationTestLanguageInjectorProvider.class)
@SuppressWarnings("all")
public class ChangeSerializerTest {
@Extension
private PartialSerializationTestLanguageFactory fac = PartialSerializationTestLanguageFactory.eINSTANCE;
@Inject
@Extension
private ChangeSerializerTestHelper _changeSerializerTestHelper;
@Test
public void testNoop() {
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, "");
}
@Test
public void testSimple() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#2 foo");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final MandatoryValue model = this._changeSerializerTestHelper.<MandatoryValue>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", MandatoryValue.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
model.setName("bar");
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#2 <3:3|bar>");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("3 3 \"foo\" -> \"bar\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testTwoChildren() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { foo1; foo2; }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
Node _get = model.getChildren().get(0);
_get.setName("bazz4");
Node _get_1 = model.getChildren().get(1);
_get_1.setName("bazz5");
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root { <10:4|bazz4>; <16:4|bazz5>; }");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("10 4 \"foo1\" -> \"bazz4\"");
_builder_1.newLine();
_builder_1.append("16 4 \"foo2\" -> \"bazz5\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testInsertOneChild() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { child1 { foo1; } }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EList<Node> _children = model.getChildren().get(0).getChildren();
Node _createNode = this.fac.createNode();
final Procedure1<Node> _function_1 = (Node it_1) -> {
it_1.setName("bazz");
};
Node _doubleArrow = ObjectExtensions.<Node>operator_doubleArrow(_createNode, _function_1);
_children.add(_doubleArrow);
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root { child1 { foo1; <25:0|bazz; >} }");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("25 0 \"\" -> \"bazz; \"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testInsertBeforeComment() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root {");
_builder.newLine();
_builder.append("\t");
_builder.append("/**/ ");
_builder.newLine();
_builder.append("\t");
_builder.append("child1;");
_builder.newLine();
_builder.append("}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EList<Node> _children = model.getChildren();
Node _createNode = this.fac.createNode();
final Procedure1<Node> _function_1 = (Node it_1) -> {
it_1.setName("bazz");
};
Node _doubleArrow = ObjectExtensions.<Node>operator_doubleArrow(_createNode, _function_1);
_children.add(0, _doubleArrow);
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root {<9:0| bazz;>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("/**/ ");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("child1;");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("9 0 \"\" -> \" bazz;\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testInsertTwoChild() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { child1 { foo1; } }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EList<Node> _children = model.getChildren().get(0).getChildren();
Node _createNode = this.fac.createNode();
final Procedure1<Node> _function_1 = (Node it_1) -> {
it_1.setName("bazz1");
};
Node _doubleArrow = ObjectExtensions.<Node>operator_doubleArrow(_createNode, _function_1);
_children.add(_doubleArrow);
EList<Node> _children_1 = model.getChildren().get(0).getChildren();
Node _createNode_1 = this.fac.createNode();
final Procedure1<Node> _function_2 = (Node it_1) -> {
it_1.setName("bazz2");
};
Node _doubleArrow_1 = ObjectExtensions.<Node>operator_doubleArrow(_createNode_1, _function_2);
_children_1.add(_doubleArrow_1);
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root { child1 { foo1; <25:0|bazz1; bazz2; >} }");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("25 0 \"\" -> \"bazz1; bazz2; \"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testDeleteChild() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { child1 { foo1; } }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EcoreUtil.remove(model.getChildren().get(0).getChildren().get(0));
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root { child1 { <19:5|> } }");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("19 5 \"foo1;\" -> \"\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testDeleteTwoChildren() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { child1; child2; }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EcoreUtil.remove(model.getChildren().get(1));
EcoreUtil.remove(model.getChildren().get(0));
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root { <10:7|> <18:7|> }");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("10 7 \"child1;\" -> \"\"");
_builder_1.newLine();
_builder_1.append("18 7 \"child2;\" -> \"\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testRenameLocal() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { foo1; foo2 { ref foo1 } }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
Node _get = model.getChildren().get(0);
_get.setName("bazz4");
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 root { <10:4|bazz4>; foo2 { ref <27:4|bazz4> } }");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("10 4 \"foo1\" -> \"bazz4\"");
_builder_1.newLine();
_builder_1.append("27 4 \"foo1\" -> \"bazz4\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testRenameGlobal1() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root1;");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("#1 root2 { ref root1 }");
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.pstl", _builder_1.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
model.setName("newroot");
};
serializer.<Resource>addModification(model.eResource(), _function);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#1 <3:5|newroot>;");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("3 5 \"root1\" -> \"newroot\"");
_builder_2.newLine();
_builder_2.append("----------------- inmemory:/file2.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#1 root2 { ref <15:5|newroot> }");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("15 5 \"root1\" -> \"newroot\"");
_builder_2.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
@Test
public void testRenameFqn1() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 r {");
_builder.newLine();
_builder.append("\t");
_builder.append("X refs a1.a2 X.a1.a2 r.X.a1.a2 { a1 { a2 refs a2 { a3 { ref a3 } } } }");
_builder.newLine();
_builder.append("\t");
_builder.append("Y refs b1.b2 Y.b1.b2 r.Y.b1.b2 { b1 { b2 { ref b2 } } }");
_builder.newLine();
_builder.append("}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
Node _head = IterableExtensions.<Node>head(IterableExtensions.<Node>head(IterableExtensions.<Node>head(model.getChildren()).getChildren()).getChildren());
_head.setName("b");
};
serializer.<Resource>addModification(model.eResource(), _function);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 r {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("X refs <15:5|a1.b> <21:7|a1.b> <29:9|a1.b> { a1 { <46:2|b> refs <54:2|b> { a3 { ref a3 } } } }");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("Y refs b1.b2 Y.b1.b2 r.Y.b1.b2 { b1 { b2 { ref b2 } } }");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("15 5 \"a1.a2\" -> \"a1.b\"");
_builder_1.newLine();
_builder_1.append("21 7 \"X.a1.a2\" -> \"a1.b\"");
_builder_1.newLine();
_builder_1.append("29 9 \"r.X.a1.a2\" -> \"a1.b\"");
_builder_1.newLine();
_builder_1.append("46 2 \"a2\" -> \"b\"");
_builder_1.newLine();
_builder_1.append("54 2 \"a2\" -> \"b\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testRenameFqn1ValueConversion() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 r {");
_builder.newLine();
_builder.append("\t");
_builder.append("X refs ^a1.^a2 ^X.^a1.^a2 ^r.^X.^a1.^a2 { a1 { a2 refs ^a2 { a3 { ref ^a3 } } } }");
_builder.newLine();
_builder.append("\t");
_builder.append("Y refs ^b1.^b2 ^Y.^b1.^b2 ^r.^Y.^b1.^b2 { b1 { b2 { ref b2 } } }");
_builder.newLine();
_builder.append("}");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
Node _head = IterableExtensions.<Node>head(IterableExtensions.<Node>head(IterableExtensions.<Node>head(model.getChildren()).getChildren()).getChildren());
_head.setName("b");
};
serializer.<Resource>addModification(model.eResource(), _function);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_1.newLine();
_builder_1.append("#1 r {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("X refs <15:7|a1.b> <23:10|a1.b> <34:13|a1.b> { a1 { <55:2|b> refs <63:3|b> { a3 { ref ^a3 } } } }");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("Y refs ^b1.^b2 ^Y.^b1.^b2 ^r.^Y.^b1.^b2 { b1 { b2 { ref b2 } } }");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("15 7 \"^a1.^a2\" -> \"a1.b\"");
_builder_1.newLine();
_builder_1.append("23 10 \"^X.^a1.^a2\" -> \"a1.b\"");
_builder_1.newLine();
_builder_1.append("34 13 \"^r.^X.^a1.^a2\" -> \"a1.b\"");
_builder_1.newLine();
_builder_1.append("55 2 \"a2\" -> \"b\"");
_builder_1.newLine();
_builder_1.append("63 3 \"^a2\" -> \"b\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testResourceURIChange() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root { }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/f.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/f.pstl", Node.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
Resource _eResource = model.eResource();
_eResource.setURI(URI.createURI("inmemory:/x.pstl"));
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("----- renamed inmemory:/f.pstl to inmemory:/x.pstl (syntax: <offset|text>) -----");
_builder_1.newLine();
_builder_1.append("(no changes)");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testAddChildElement() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#22 {");
_builder.newLine();
_builder.append("\t");
_builder.append("child1");
_builder.newLine();
_builder.append("\t");
_builder.append("children1 {");
_builder.newLine();
_builder.append("\t\t");
_builder.append("child2 child3");
_builder.newLine();
_builder.append("\t");
_builder.append("}");
_builder.newLine();
_builder.append("}");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file-move.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final TwoChildLists model = this._changeSerializerTestHelper.<TwoChildLists>findFirstOfTypeInFile(rs, "inmemory:/file-move.pstl", TwoChildLists.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EList<MandatoryValue> _directChildren = model.getDirectChildren();
MandatoryValue _createMandatoryValue = this.fac.createMandatoryValue();
final Procedure1<MandatoryValue> _function_1 = (MandatoryValue it_1) -> {
it_1.setName("newChild");
};
MandatoryValue _doubleArrow = ObjectExtensions.<MandatoryValue>operator_doubleArrow(_createMandatoryValue, _function_1);
_directChildren.add(_doubleArrow);
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("--------------- inmemory:/file-move.pstl (syntax: <offset|text>) ---------------");
_builder_1.newLine();
_builder_1.append("#22 {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("child1<13:0| newChild>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("children1 {");
_builder_1.newLine();
_builder_1.append("\t\t");
_builder_1.append("child2 child3");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("13 0 \"\" -> \" newChild\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testMoveElement() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#22 {");
_builder.newLine();
_builder.append("\t");
_builder.append("child1");
_builder.newLine();
_builder.append("\t");
_builder.append("children1 {");
_builder.newLine();
_builder.append("\t\t");
_builder.append("child2 jumper");
_builder.newLine();
_builder.append("\t");
_builder.append("}");
_builder.newLine();
_builder.append("}");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file-move1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final TwoChildLists model = this._changeSerializerTestHelper.<TwoChildLists>findFirstOfTypeInFile(rs, "inmemory:/file-move1.pstl", TwoChildLists.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
final Function1<MandatoryValue, Boolean> _function_1 = (MandatoryValue it_1) -> {
String _name = it_1.getName();
return Boolean.valueOf(Objects.equal(_name, "jumper"));
};
model.getDirectChildren().add(IterableExtensions.<MandatoryValue>findFirst(model.getChildsList().getChildren(), _function_1));
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("-------------- inmemory:/file-move1.pstl (syntax: <offset|text>) ---------------");
_builder_1.newLine();
_builder_1.append("#22 {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("child1<13:0| jumper>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("children1 {");
_builder_1.newLine();
_builder_1.append("\t\t");
_builder_1.append("child2 <36:6|>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("13 0 \"\" -> \" jumper\"");
_builder_1.newLine();
_builder_1.append("36 6 \"jumper\" -> \"\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testMoveElement_2() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#22 {");
_builder.newLine();
_builder.append("\t");
_builder.append("child1");
_builder.newLine();
_builder.append("\t");
_builder.append("children1 {");
_builder.newLine();
_builder.append("\t\t");
_builder.append("child2 jumper");
_builder.newLine();
_builder.append("\t");
_builder.append("}");
_builder.newLine();
_builder.append("}");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file-move.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final TwoChildLists model = this._changeSerializerTestHelper.<TwoChildLists>findFirstOfTypeInFile(rs, "inmemory:/file-move.pstl", TwoChildLists.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
final Function1<MandatoryValue, Boolean> _function_1 = (MandatoryValue it_1) -> {
String _name = it_1.getName();
return Boolean.valueOf(Objects.equal(_name, "jumper"));
};
model.getDirectChildren().add(0, IterableExtensions.<MandatoryValue>findFirst(model.getChildsList().getChildren(), _function_1));
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("--------------- inmemory:/file-move.pstl (syntax: <offset|text>) ---------------");
_builder_1.newLine();
_builder_1.append("#22 {<5:0| jumper>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("child1");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("children1 {");
_builder_1.newLine();
_builder_1.append("\t\t");
_builder_1.append("child2 <36:6|>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("5 0 \"\" -> \" jumper\"");
_builder_1.newLine();
_builder_1.append("36 6 \"jumper\" -> \"\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testMoveElement_2a() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#22 {");
_builder.newLine();
_builder.append("\t");
_builder.append("child1 child3");
_builder.newLine();
_builder.append("\t");
_builder.append("children1 {");
_builder.newLine();
_builder.append("\t\t");
_builder.append("child2 jumper");
_builder.newLine();
_builder.append("\t");
_builder.append("}");
_builder.newLine();
_builder.append("}");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file-move2a.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final TwoChildLists model = this._changeSerializerTestHelper.<TwoChildLists>findFirstOfTypeInFile(rs, "inmemory:/file-move2a.pstl", TwoChildLists.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
final Function1<MandatoryValue, Boolean> _function_1 = (MandatoryValue it_1) -> {
String _name = it_1.getName();
return Boolean.valueOf(Objects.equal(_name, "jumper"));
};
model.getDirectChildren().add(1, IterableExtensions.<MandatoryValue>findFirst(model.getChildsList().getChildren(), _function_1));
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("-------------- inmemory:/file-move2a.pstl (syntax: <offset|text>) --------------");
_builder_1.newLine();
_builder_1.append("#22 {");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("child1 <14:0|jumper >child3");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("children1 {");
_builder_1.newLine();
_builder_1.append("\t\t");
_builder_1.append("child2 <43:6|>");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("}");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("14 0 \"\" -> \"jumper \"");
_builder_1.newLine();
_builder_1.append("43 6 \"jumper\" -> \"\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testMoveElement_3() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#24 direct:");
_builder.newLine();
_builder.append("\t");
_builder.append("child:jumper");
_builder.newLine();
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file-move3.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final TwoChilds model = this._changeSerializerTestHelper.<TwoChilds>findFirstOfTypeInFile(rs, "inmemory:/file-move3.pstl", TwoChilds.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
model.setDirectChild(model.getOptChild().getChild());
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("-------------- inmemory:/file-move3.pstl (syntax: <offset|text>) ---------------");
_builder_1.newLine();
_builder_1.append("<0:26|#24 direct:");
_builder_1.newLine();
_builder_1.append("\t");
_builder_1.append("jumper");
_builder_1.newLine();
_builder_1.append("child :>");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("0 26 \"#24 direct:\\n\tchil...\" -> \"#24 direct:\\n\tjump...\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
@Test
public void testAddElements() {
final String uri = "inmemory:/file-add.pstl";
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#23");
Pair<String, String> _mappedTo = Pair.<String, String>of(uri, _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final ChildWithSubChilds model = this._changeSerializerTestHelper.<ChildWithSubChilds>findFirstOfTypeInFile(rs, uri, ChildWithSubChilds.class);
final IChangeSerializer serializer = this._changeSerializerTestHelper.newChangeSerializer();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EList<ChildWithSubChild> _children = model.getChildren();
ChildWithSubChild _createChildWithSubChild = this.fac.createChildWithSubChild();
final Procedure1<ChildWithSubChild> _function_1 = (ChildWithSubChild it_1) -> {
EList<SubChild> _subChilds = it_1.getSubChilds();
SubChild _createSubChild = this.fac.createSubChild();
final Procedure1<SubChild> _function_2 = (SubChild it_2) -> {
it_2.setName("A");
};
SubChild _doubleArrow = ObjectExtensions.<SubChild>operator_doubleArrow(_createSubChild, _function_2);
_subChilds.add(_doubleArrow);
};
ChildWithSubChild _doubleArrow = ObjectExtensions.<ChildWithSubChild>operator_doubleArrow(_createChildWithSubChild, _function_1);
_children.add(_doubleArrow);
ChildWithSubChild _head = IterableExtensions.<ChildWithSubChild>head(model.getChildren());
final Procedure1<ChildWithSubChild> _function_2 = (ChildWithSubChild it_1) -> {
EList<SubChild> _subChilds = it_1.getSubChilds();
SubChild _createSubChild = this.fac.createSubChild();
final Procedure1<SubChild> _function_3 = (SubChild it_2) -> {
it_2.setName("A2");
};
SubChild _doubleArrow_1 = ObjectExtensions.<SubChild>operator_doubleArrow(_createSubChild, _function_3);
_subChilds.add(_doubleArrow_1);
};
ObjectExtensions.<ChildWithSubChild>operator_doubleArrow(_head, _function_2);
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("--------------- inmemory:/file-add.pstl (syntax: <offset|text>) ----------------");
_builder_1.newLine();
_builder_1.append("<0:3|#23 subs A A2>");
_builder_1.newLine();
_builder_1.append("--------------------------------------------------------------------------------");
_builder_1.newLine();
_builder_1.append("0 3 \"#23\" -> \"#23 subs A A2\"");
_builder_1.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_1);
}
}

View file

@ -1,226 +0,0 @@
/**
* Copyright (c) 2017, 2020 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.serializer;
import com.google.inject.Inject;
import com.google.inject.Provider;
import java.util.Collection;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.ide.serializer.IChangeSerializer;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.EClassRef;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Model;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.IterableExtensions;
import org.eclipse.xtext.xbase.lib.ObjectExtensions;
import org.eclipse.xtext.xbase.lib.Pair;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(PartialSerializationTestLanguageInjectorProviderWithEmf.class)
@SuppressWarnings("all")
public class ChangeSerializerWithEmfTest {
@Inject
private Provider<ChangeSerializer> serializerProvider;
@Inject
@Extension
private ChangeSerializerTestHelper _changeSerializerTestHelper;
@Test
public void testChangeRefToXML() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#21 MyPackage.MyClass1");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
_builder_1.newLine();
_builder_1.append("<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("<eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\" eSuperTypes=\"#//MyClass2\"/>");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("<eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass2\"/>");
_builder_1.newLine();
_builder_1.append("</ecore:EPackage>");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.ecore", _builder_1.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final EClassRef model = this._changeSerializerTestHelper.<EClassRef>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", EClassRef.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<EClassRef> _function = (EClassRef it) -> {
EClassifier _get = model.getRef().getEPackage().getEClassifiers().get(1);
model.setRef(((EClass) _get));
};
serializer.<EClassRef>addModification(model, _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#21 <4:18|MyPackage.MyClass2>");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("4 18 \"MyPackage.MyClass1\" -> \"MyPackage.MyClass2\"");
_builder_2.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
@Test
public void testChangeInXML() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#21 MyPackage.MyClass1");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
_builder_1.newLine();
_builder_1.append("<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("<eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\"/>");
_builder_1.newLine();
_builder_1.append("</ecore:EPackage>");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.ecore", _builder_1.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final EPackage model = this._changeSerializerTestHelper.<EPackage>findFirstOfTypeInFile(rs, "inmemory:/file2.ecore", EPackage.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<EPackage> _function = (EPackage it) -> {
EClassifier _head = IterableExtensions.<EClassifier>head(model.getEClassifiers());
((EClass) _head).setName("NewClass");
};
serializer.<EPackage>addModification(model, _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("---------------------------- inmemory:/file2.ecore -----------------------------");
_builder_2.newLine();
_builder_2.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
_builder_2.newLine();
_builder_2.append("<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
_builder_2.newLine();
_builder_2.append(" ");
_builder_2.append("xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">");
_builder_2.newLine();
_builder_2.append(" ");
_builder_2.append("<eClassifiers xsi:type=\"ecore:EClass\" name=\"NewClass\"/>");
_builder_2.newLine();
_builder_2.append("</ecore:EPackage>");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#21 <4:18|MyPackage.NewClass>");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("4 18 \"MyPackage.MyClass1\" -> \"MyPackage.NewClass\"");
_builder_2.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
@Test
public void testChangeInDSL() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#20 DslEClass");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
_builder_1.newLine();
_builder_1.append("<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">");
_builder_1.newLine();
_builder_1.append(" ");
_builder_1.append("<eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\" eSuperTypes=\"inmemory:/file1.pstl#//@clazz.0\"/>");
_builder_1.newLine();
_builder_1.append("</ecore:EPackage>");
_builder_1.newLine();
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.ecore", _builder_1.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Model model = this._changeSerializerTestHelper.<Model>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Model.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
EClass _get = model.getClazz().get(0);
_get.setName("ChangedName");
EList<EClass> _clazz = model.getClazz();
EClass _createEClass = EcoreFactory.eINSTANCE.createEClass();
final Procedure1<EClass> _function_1 = (EClass it_1) -> {
it_1.setName("NewName");
};
EClass _doubleArrow = ObjectExtensions.<EClass>operator_doubleArrow(_createEClass, _function_1);
_clazz.add(0, _doubleArrow);
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#20 <4:0|NewName ><4:9| ChangedName>");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("4 0 \"\" -> \"NewName \"");
_builder_2.newLine();
_builder_2.append("4 9 \"DslEClass\" -> \" ChangedName\"");
_builder_2.newLine();
_builder_2.append("---------------------------- inmemory:/file2.ecore -----------------------------");
_builder_2.newLine();
_builder_2.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
_builder_2.newLine();
_builder_2.append("<ecore:EPackage xmi:version=\"2.0\" xmlns:xmi=\"http://www.omg.org/XMI\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
_builder_2.newLine();
_builder_2.append(" ");
_builder_2.append("xmlns:ecore=\"http://www.eclipse.org/emf/2002/Ecore\" name=\"MyPackage\">");
_builder_2.newLine();
_builder_2.append(" ");
_builder_2.append("<eClassifiers xsi:type=\"ecore:EClass\" name=\"MyClass1\" eSuperTypes=\"file1.pstl#//@clazz.1\"/>");
_builder_2.newLine();
_builder_2.append("</ecore:EPackage>");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
}

View file

@ -1,87 +0,0 @@
/**
* Copyright (c) 2017 TypeFox GmbH (http://www.typefox.io) and others.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.xtext.ide.tests.serializer;
import com.google.inject.Inject;
import com.google.inject.Provider;
import java.util.Collection;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.ide.serializer.IChangeSerializer;
import org.eclipse.xtext.ide.serializer.IEmfResourceChange;
import org.eclipse.xtext.ide.serializer.impl.ChangeSerializer;
import org.eclipse.xtext.ide.tests.testlanguage.partialSerializationTestLanguage.Node;
import org.eclipse.xtext.ide.tests.testlanguage.tests.PartialSerializationTestLanguageInjectorProvider;
import org.eclipse.xtext.testing.InjectWith;
import org.eclipse.xtext.testing.XtextRunner;
import org.eclipse.xtext.testing.util.InMemoryURIHandler;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Pair;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
/**
* @author Moritz Eysholdt - Initial contribution and API
*/
@RunWith(XtextRunner.class)
@InjectWith(PartialSerializationTestLanguageInjectorProvider.class)
@SuppressWarnings("all")
public class ChangeSerializerWithImports {
@Inject
private Provider<ChangeSerializer> serializerProvider;
@Inject
@Extension
private ChangeSerializerTestHelper _changeSerializerTestHelper;
@Test
public void testRenameGlobal1() {
final InMemoryURIHandler fs = new InMemoryURIHandler();
StringConcatenation _builder = new StringConcatenation();
_builder.append("#1 root1 { child1; }");
Pair<String, String> _mappedTo = Pair.<String, String>of("inmemory:/file1.pstl", _builder.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo);
StringConcatenation _builder_1 = new StringConcatenation();
_builder_1.append("#1 import root1.child1 refs child1;");
Pair<String, String> _mappedTo_1 = Pair.<String, String>of("inmemory:/file2.pstl", _builder_1.toString());
this._changeSerializerTestHelper.operator_add(fs, _mappedTo_1);
final ResourceSet rs = this._changeSerializerTestHelper.createResourceSet(fs);
final Node model = this._changeSerializerTestHelper.<Node>findFirstOfTypeInFile(rs, "inmemory:/file1.pstl", Node.class);
final ChangeSerializer serializer = this.serializerProvider.get();
final IChangeSerializer.IModification<Resource> _function = (Resource it) -> {
Node _get = model.getChildren().get(0);
_get.setName("newchild");
Assert.assertEquals(1, model.eResource().getResourceSet().getResources().size());
};
serializer.<Resource>addModification(model.eResource(), _function);
Collection<IEmfResourceChange> _endRecordChangesToTextDocuments = this._changeSerializerTestHelper.endRecordChangesToTextDocuments(serializer);
StringConcatenation _builder_2 = new StringConcatenation();
_builder_2.append("----------------- inmemory:/file1.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#1 root1 { <11:6|newchild>; }");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("11 6 \"child1\" -> \"newchild\"");
_builder_2.newLine();
_builder_2.append("----------------- inmemory:/file2.pstl (syntax: <offset|text>) -----------------");
_builder_2.newLine();
_builder_2.append("#1 import <10:12|root1.newchild> refs <28:6|newchild>;");
_builder_2.newLine();
_builder_2.append("--------------------------------------------------------------------------------");
_builder_2.newLine();
_builder_2.append("10 12 \"root1.child1\" -> \"root1.newchild\"");
_builder_2.newLine();
_builder_2.append("28 6 \"child1\" -> \"newchild\"");
_builder_2.newLine();
this._changeSerializerTestHelper.operator_tripleEquals(_endRecordChangesToTextDocuments, _builder_2);
}
}