Testing multiple Xtext DSLs

Recently there was a question in the Eclipse forum about testing multiple Xtext languages. The described scenario involves two language and one should have cross references to the other. Since this usecase caused some headaches in the past, Michael Vorburger provided a patch (Thanks for that!) that adds information about that particular topic to the official Xtext documentation. The updated docs are available since the recent 2.7 release. To provide some additional guidance, I hacked a small example that can be used as a blueprint if you want to get a jump start on that issue. This example also documents briefly how Xtext's unit test facilities can be used for effective language testing.

Key to testing the infrastructure of a DSL is the setup of a proper test environment. The Guice services have to be registered, EMF has to be initialized and obviously everything has to be cleaned up again after a test has been executed. For that purpose, Xtext provides a dedicated Junit4 test runner that uses an injector provider to do the initialization. The nice thing about that approach is that you can directly inject the necessary services into your unit test class. Exaclty as you are used to in your production code, too.

	@RunWith(XtextRunner)
	@InjectWith(MyDSLInjectorProvider)
	class MyTest {
	// Helper to read models
	@Inject ParseHelper<MyModel> parseHelper
	// Helper to test all validation rules and ensure resolved links
	@Inject ValidationTestHelper validationTester
	@Test def void myTest() {
	val model = parseHelper.parse('Hello World!')
	validationTester.assertNoIssues(model)
	}
	}

view raw UnitTest.xtend hosted with ❤ by GitHub

When it comes to testing multiple DSLs, basically the same infrastructure can be used, though you have to make sure, that all involved languages are properly initialized. For that purpose, a custom injector provider has to be derived from the one, that was already generated for your language. The to-be-written subclass needs to takes care of all the prerequisites and register the dependent languages. This mainly involves delegation to their injector providers.

	class MultiLangInjectorProvider extends MyDslInjectorProvider {
	override protected internalCreateInjector() {
	// trigger injector creation of other language
	new SecondDslInjectorProvider().getInjector
	return super.internalCreateInjector()
	}
	}

view raw MultiLangInjectorProvider.xtend hosted with ❤ by GitHub

Now that the setup is ready, we can test cross references between multiple DSLs. It is important to know that these references are only properly resolved if all models are available in the same resource set. That's why we need to use an explicit resource set in the tests. Besides that, it's the programming model that you know from Xtext and EMF in general.

	@Test def void successfulLanguageTest() {
	val resourceSet = resourceSetProvider.get
	// create a resource for language 'MyDsl'
	val firstLang = resourceSet.createResource(URI.createURI("sample.mydsl"))
	// parse some contents
	firstLang.load(new StringInputStream(".."), emptyMap)
	// and read the root instance
	val root = firstLang.contents.head as MyDslRoot
	// ensure it's not null
	assertNotNull(root)
	// and valid
	validationTester.assertNoIssues(root)
	// use the parse helper to read the model under test
	// into the same resource set
	val testMe = parseHelper.parse("..", resourceSet)
	// it's not null, too
	assertNotNull(testMe)
	// and also valid
	validationTester.assertNoIssues(testMe)
	// more assertions below
	..
	}

view raw MultiLangTest.xtend hosted with ❤ by GitHub

A complete examplary test is available on Github.