diff --git a/releng/Papyrus - Rpy - Main.launch b/releng/Papyrus - Rpy - Main.launch
new file mode 100755
index 0000000..25dc7d5
--- /dev/null
+++ b/releng/Papyrus - Rpy - Main.launch
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.m2e.Maven2LaunchConfigurationType">
+<booleanAttribute key="M2_DEBUG_OUTPUT" value="false"/>
+<stringAttribute key="M2_GOALS" value="clean install"/>
+<booleanAttribute key="M2_NON_RECURSIVE" value="false"/>
+<booleanAttribute key="M2_OFFLINE" value="false"/>
+<stringAttribute key="M2_PROFILES" value="Rpy"/>
+<listAttribute key="M2_PROPERTIES">
+<listEntry value="eclipse.p2.mirrors=false"/>
+</listAttribute>
+<stringAttribute key="M2_RUNTIME" value="EMBEDDED"/>
+<booleanAttribute key="M2_SKIP_TESTS" value="false"/>
+<intAttribute key="M2_THREADS" value="1"/>
+<booleanAttribute key="M2_UPDATE_SNAPSHOTS" value="false"/>
+<stringAttribute key="M2_USER_SETTINGS" value=""/>
+<booleanAttribute key="M2_WORKSPACE_RESOLUTION" value="false"/>
+<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${project_loc:releng}/main"/>
+</launchConfiguration>
diff --git a/releng/Papyrus - Rpy - Test.launch b/releng/Papyrus - Rpy - Test.launch
new file mode 100755
index 0000000..6c442bd
--- /dev/null
+++ b/releng/Papyrus - Rpy - Test.launch
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.m2e.Maven2LaunchConfigurationType">
+<booleanAttribute key="M2_DEBUG_OUTPUT" value="false"/>
+<stringAttribute key="M2_GOALS" value="clean verify"/>
+<booleanAttribute key="M2_NON_RECURSIVE" value="false"/>
+<booleanAttribute key="M2_OFFLINE" value="false"/>
+<stringAttribute key="M2_PROFILES" value="Rpy"/>
+<listAttribute key="M2_PROPERTIES">
+<listEntry value="papyrus.repo.interoperability.main=file:/${project_loc:releng}/../rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/target/repository"/>
+</listAttribute>
+<stringAttribute key="M2_RUNTIME" value="EMBEDDED"/>
+<booleanAttribute key="M2_SKIP_TESTS" value="false"/>
+<intAttribute key="M2_THREADS" value="1"/>
+<booleanAttribute key="M2_UPDATE_SNAPSHOTS" value="false"/>
+<stringAttribute key="M2_USER_SETTINGS" value=""/>
+<booleanAttribute key="M2_WORKSPACE_RESOLUTION" value="false"/>
+<stringAttribute key="org.eclipse.jdt.launching.WORKING_DIRECTORY" value="${project_loc:releng}/tests"/>
+</launchConfiguration>
diff --git a/rpy/features/.gitkeep b/rpy/features/.gitkeep
deleted file mode 100644
index e69de29..0000000
--- a/rpy/features/.gitkeep
+++ /dev/null
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/.project b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/.project
new file mode 100644
index 0000000..a7ecb71
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/build.properties b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/build.properties
new file mode 100644
index 0000000..67be479
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               epl-v10.html,\
+               license.html
+src.includes = epl-v10.html,\
+               license.html
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/epl-v10.html b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/epl-v10.html
new file mode 100644
index 0000000..cb1073a
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/epl-v10.html
@@ -0,0 +1,304 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<html xmlns:o="urn:schemas-microsoft-com:office:office"
+xmlns:w="urn:schemas-microsoft-com:office:word"
+xmlns="http://www.w3.org/TR/REC-html40">
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<link rel=File-List
+href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
+<title>Eclipse Public License - Version 1.0</title>
+<style>
+<!--
+ /* Font Definitions */
+@font-face
+	{
+	panose-1:2 11 6 4 3 5 4 4 2 4;
+	mso-font-charset:0;
+	mso-font-pitch:variable;
+	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
+ /* Style Definitions */
+p.MsoNormal, li.MsoNormal, div.MsoNormal
+	{mso-style-parent:"";
+	margin:0in;
+	margin-bottom:.0001pt;
+	mso-pagination:widow-orphan;
+	font-size:12.0pt;
+	}
+p
+	{margin-right:0in;
+	mso-margin-top-alt:auto;
+	mso-margin-bottom-alt:auto;
+	margin-left:0in;
+	mso-pagination:widow-orphan;
+	font-size:12.0pt;
+	}
+p.BalloonText, li.BalloonText, div.BalloonText
+	{mso-style-name:"Balloon Text";
+	margin:0in;
+	margin-bottom:.0001pt;
+	mso-pagination:widow-orphan;
+	font-size:8.0pt;
+	
+	}
+@page Section1
+	{size:8.5in 11.0in;
+	margin:1.0in 1.25in 1.0in 1.25in;
+	mso-header-margin:.5in;
+	mso-footer-margin:.5in;
+	mso-paper-source:0;}
+div.Section1
+	{page:Section1;}
+-->
+</style>
+</head>
+
+<body lang="EN-US" style='tab-interval:.5in'>
+
+<div class=Section1>
+
+<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
+</p>
+
+<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
+THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
+REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
+OF THIS AGREEMENT.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
+
+<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+in the case of the initial Contributor, the initial code and documentation
+distributed under this Agreement, and<br clear=left>
+b) in the case of each subsequent Contributor:</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
+changes to the Program, and</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
+additions to the Program;</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
+such changes and/or additions to the Program originate from and are distributed
+by that particular Contributor. A Contribution 'originates' from a Contributor
+if it was added to the Program by such Contributor itself or anyone acting on
+such Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in conjunction
+with the Program under their own license agreement, and (ii) are not derivative
+works of the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
+entity that distributes the Program.</span> </p>
+
+<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
+claims licensable by a Contributor which are necessarily infringed by the use
+or sale of its Contribution alone or when combined with the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
+distributed in accordance with this Agreement.</span> </p>
+
+<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
+receives the Program under this Agreement, including all Contributors.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+Subject to the terms of this Agreement, each Contributor hereby grants Recipient
+a non-exclusive, worldwide, royalty-free copyright license to<span
+style='color:red'> </span>reproduce, prepare derivative works of, publicly
+display, publicly perform, distribute and sublicense the Contribution of such
+Contributor, if any, and such derivative works, in source code and object code
+form.</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
+Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
+patent license under Licensed Patents to make, use, sell, offer to sell, import
+and otherwise transfer the Contribution of such Contributor, if any, in source
+code and object code form. This patent license shall apply to the combination
+of the Contribution and the Program if, at the time the Contribution is added
+by the Contributor, such addition of the Contribution causes such combination
+to be covered by the Licensed Patents. The patent license shall not apply to
+any other combinations which include the Contribution. No hardware per se is
+licensed hereunder. </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
+Recipient understands that although each Contributor grants the licenses to its
+Contributions set forth herein, no assurances are provided by any Contributor
+that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient
+for claims brought by any other entity based on infringement of intellectual
+property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility
+to secure any other intellectual property rights needed, if any. For example,
+if a third party patent license is required to allow Recipient to distribute
+the Program, it is Recipient's responsibility to acquire that license before
+distributing the Program.</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
+Each Contributor represents that to its knowledge it has sufficient copyright
+rights in its Contribution, if any, to grant the copyright license set forth in
+this Agreement. </span></p>
+
+<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
+
+<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
+Program in object code form under its own license agreement, provided that:</span>
+</p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+it complies with the terms and conditions of this Agreement; and</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
+its license agreement:</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
+effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title
+and non-infringement, and implied warranties or conditions of merchantability
+and fitness for a particular purpose; </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
+effectively excludes on behalf of all Contributors all liability for damages,
+including direct, indirect, special, incidental and consequential damages, such
+as lost profits; </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
+states that any provisions which differ from this Agreement are offered by that
+Contributor alone and not by any other party; and</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
+states that source code for the Program is available from such Contributor, and
+informs licensees how to obtain it in a reasonable manner on or through a
+medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
+
+<p><span style='font-size:10.0pt'>When the Program is made available in source
+code form:</span> </p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+it must be made available under this Agreement; and </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
+copy of this Agreement must be included with each copy of the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
+copyright notices contained within the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
+originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution. </span></p>
+
+<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
+
+<p><span style='font-size:10.0pt'>Commercial distributors of software may
+accept certain responsibilities with respect to end users, business partners
+and the like. While this license is intended to facilitate the commercial use
+of the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes the
+Program in a commercial product offering, such Contributor (&quot;Commercial
+Contributor&quot;) hereby agrees to defend and indemnify every other
+Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
+costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
+legal actions brought by a third party against the Indemnified Contributor to
+the extent caused by the acts or omissions of such Commercial Contributor in
+connection with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In order
+to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor
+to control, and cooperate with the Commercial Contributor in, the defense and
+any related settlement negotiations. The Indemnified Contributor may participate
+in any such claim at its own expense.</span> </p>
+
+<p><span style='font-size:10.0pt'>For example, a Contributor might include the
+Program in a commercial product offering, Product X. That Contributor is then a
+Commercial Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance claims and
+warranties are such Commercial Contributor's responsibility alone. Under this
+section, the Commercial Contributor would have to defend claims against the
+other Contributors related to those performance claims and warranties, and if a
+court requires any other Contributor to pay any damages as a result, the
+Commercial Contributor must pay those damages.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
+
+<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
+AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and distributing the
+Program and assumes all risks associated with its exercise of rights under this
+Agreement , including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs or
+equipment, and unavailability or interruption of operations. </span></p>
+
+<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
+
+<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
+AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
+THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
+
+<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
+or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without
+further action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.</span> </p>
+
+<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with
+other software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the date
+such litigation is filed. </span></p>
+
+<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
+shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable
+period of time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive. </span></p>
+
+<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
+copies of this Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The Agreement
+Steward reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement Steward has
+the right to modify this Agreement. The Eclipse Foundation is the initial
+Agreement Steward. The Eclipse Foundation may assign the responsibility to
+serve as the Agreement Steward to a suitable separate entity. Each new version
+of the Agreement will be given a distinguishing version number. The Program
+(including Contributions) may always be distributed subject to the version of
+the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly stated
+in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether
+expressly, by implication, estoppel or otherwise. All rights in the Program not
+expressly granted under this Agreement are reserved.</span> </p>
+
+<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
+State of New York and the intellectual property laws of the United States of
+America. No party to this Agreement will bring a legal action under this
+Agreement more than one year after the cause of action arose. Each party waives
+its rights to a jury trial in any resulting litigation.</span> </p>
+
+<p class=MsoNormal></p>
+
+</div>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/feature.xml b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/feature.xml
new file mode 100644
index 0000000..60433f9
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/feature.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.papyrus.interoperability.rpy.feature"
+      label="Papyrus Interoperability Rpy Feature (Incubation)"
+      version="0.7.0.qualifier"
+      provider-name="Eclipse Modeling Project">
+
+   <description>
+      This component allows importing rpy file (created with IBM Rational Rhapsody software) as UML models.
+   </description>
+
+   <copyright>
+      Copyright (c) 2016 CEA LIST.
+All rights reserved.
+   </copyright>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.metamodel"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.metamodel.edit"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.metamodel.editor"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+         
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.blackboxes"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.doc"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+         
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.geometry"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>         
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.parser"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>         
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.parser.ui"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>         
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.toolsmiths.api.discovery"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.apache.commons.io"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.common"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.common.blackboxes"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/license.html b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/license.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/license.html
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>April 9, 2014</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+   repository (&quot;Repository&quot;) in software modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
+Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license (&quot;Feature Update License&quot;) during the
+installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager (&quot;Provisioning Technology&quot;) for the purpose of allowing users to install software, documentation, information and/or
+   other materials (collectively &quot;Installable Software&quot;). This capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+       href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   (&quot;Specification&quot;).</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+   in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+   Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur (&quot;Provisioning Process&quot;) in which a user may execute the Provisioning Technology
+       on a machine (&quot;Target Machine&quot;) with the intent of installing, extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+       Software (&quot;Installable Software Agreement&quot;) and such Installable Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+       the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+       indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/pom.xml b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/pom.xml
new file mode 100644
index 0000000..4ecc8cc
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.feature/pom.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.releng</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<relativePath>../../../releng/main/pom.xml</relativePath>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.feature</artifactId>
+	<groupId>org.eclipse.papyrus</groupId>
+	<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-feature</packaging>
+</project>
\ No newline at end of file
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.p2/.project b/rpy/features/org.eclipse.papyrus.interoperability.rpy.p2/.project
new file mode 100755
index 0000000..3755ddd
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.p2/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.p2</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/.project b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/.project
new file mode 100755
index 0000000..afb6417
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.tests.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/build.properties b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/build.properties
new file mode 100755
index 0000000..67be479
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/build.properties
@@ -0,0 +1,5 @@
+bin.includes = feature.xml,\
+               epl-v10.html,\
+               license.html
+src.includes = epl-v10.html,\
+               license.html
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/epl-v10.html b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/epl-v10.html
new file mode 100755
index 0000000..cb1073a
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/epl-v10.html
@@ -0,0 +1,304 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
+<html xmlns:o="urn:schemas-microsoft-com:office:office"
+xmlns:w="urn:schemas-microsoft-com:office:word"
+xmlns="http://www.w3.org/TR/REC-html40">
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<link rel=File-List
+href="./Eclipse%20EPL%202003_11_10%20Final_files/filelist.xml">
+<title>Eclipse Public License - Version 1.0</title>
+<style>
+<!--
+ /* Font Definitions */
+@font-face
+	{
+	panose-1:2 11 6 4 3 5 4 4 2 4;
+	mso-font-charset:0;
+	mso-font-pitch:variable;
+	mso-font-signature:553679495 -2147483648 8 0 66047 0;}
+ /* Style Definitions */
+p.MsoNormal, li.MsoNormal, div.MsoNormal
+	{mso-style-parent:"";
+	margin:0in;
+	margin-bottom:.0001pt;
+	mso-pagination:widow-orphan;
+	font-size:12.0pt;
+	}
+p
+	{margin-right:0in;
+	mso-margin-top-alt:auto;
+	mso-margin-bottom-alt:auto;
+	margin-left:0in;
+	mso-pagination:widow-orphan;
+	font-size:12.0pt;
+	}
+p.BalloonText, li.BalloonText, div.BalloonText
+	{mso-style-name:"Balloon Text";
+	margin:0in;
+	margin-bottom:.0001pt;
+	mso-pagination:widow-orphan;
+	font-size:8.0pt;
+	
+	}
+@page Section1
+	{size:8.5in 11.0in;
+	margin:1.0in 1.25in 1.0in 1.25in;
+	mso-header-margin:.5in;
+	mso-footer-margin:.5in;
+	mso-paper-source:0;}
+div.Section1
+	{page:Section1;}
+-->
+</style>
+</head>
+
+<body lang="EN-US" style='tab-interval:.5in'>
+
+<div class=Section1>
+
+<p align=center style='text-align:center'><b>Eclipse Public License - v 1.0</b>
+</p>
+
+<p><span style='font-size:10.0pt'>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER
+THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (&quot;AGREEMENT&quot;). ANY USE,
+REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE
+OF THIS AGREEMENT.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>1. DEFINITIONS</span></b> </p>
+
+<p><span style='font-size:10.0pt'>&quot;Contribution&quot; means:</span> </p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+in the case of the initial Contributor, the initial code and documentation
+distributed under this Agreement, and<br clear=left>
+b) in the case of each subsequent Contributor:</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
+changes to the Program, and</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
+additions to the Program;</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>where
+such changes and/or additions to the Program originate from and are distributed
+by that particular Contributor. A Contribution 'originates' from a Contributor
+if it was added to the Program by such Contributor itself or anyone acting on
+such Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in conjunction
+with the Program under their own license agreement, and (ii) are not derivative
+works of the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>&quot;Contributor&quot; means any person or
+entity that distributes the Program.</span> </p>
+
+<p><span style='font-size:10.0pt'>&quot;Licensed Patents &quot; mean patent
+claims licensable by a Contributor which are necessarily infringed by the use
+or sale of its Contribution alone or when combined with the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>&quot;Program&quot; means the Contributions
+distributed in accordance with this Agreement.</span> </p>
+
+<p><span style='font-size:10.0pt'>&quot;Recipient&quot; means anyone who
+receives the Program under this Agreement, including all Contributors.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>2. GRANT OF RIGHTS</span></b> </p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+Subject to the terms of this Agreement, each Contributor hereby grants Recipient
+a non-exclusive, worldwide, royalty-free copyright license to<span
+style='color:red'> </span>reproduce, prepare derivative works of, publicly
+display, publicly perform, distribute and sublicense the Contribution of such
+Contributor, if any, and such derivative works, in source code and object code
+form.</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
+Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide,<span style='color:green'> </span>royalty-free
+patent license under Licensed Patents to make, use, sell, offer to sell, import
+and otherwise transfer the Contribution of such Contributor, if any, in source
+code and object code form. This patent license shall apply to the combination
+of the Contribution and the Program if, at the time the Contribution is added
+by the Contributor, such addition of the Contribution causes such combination
+to be covered by the Licensed Patents. The patent license shall not apply to
+any other combinations which include the Contribution. No hardware per se is
+licensed hereunder. </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>c)
+Recipient understands that although each Contributor grants the licenses to its
+Contributions set forth herein, no assurances are provided by any Contributor
+that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient
+for claims brought by any other entity based on infringement of intellectual
+property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility
+to secure any other intellectual property rights needed, if any. For example,
+if a third party patent license is required to allow Recipient to distribute
+the Program, it is Recipient's responsibility to acquire that license before
+distributing the Program.</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>d)
+Each Contributor represents that to its knowledge it has sufficient copyright
+rights in its Contribution, if any, to grant the copyright license set forth in
+this Agreement. </span></p>
+
+<p><b><span style='font-size:10.0pt'>3. REQUIREMENTS</span></b> </p>
+
+<p><span style='font-size:10.0pt'>A Contributor may choose to distribute the
+Program in object code form under its own license agreement, provided that:</span>
+</p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+it complies with the terms and conditions of this Agreement; and</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b)
+its license agreement:</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>i)
+effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title
+and non-infringement, and implied warranties or conditions of merchantability
+and fitness for a particular purpose; </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>ii)
+effectively excludes on behalf of all Contributors all liability for damages,
+including direct, indirect, special, incidental and consequential damages, such
+as lost profits; </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iii)
+states that any provisions which differ from this Agreement are offered by that
+Contributor alone and not by any other party; and</span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>iv)
+states that source code for the Program is available from such Contributor, and
+informs licensees how to obtain it in a reasonable manner on or through a
+medium customarily used for software exchange.<span style='color:blue'> </span></span></p>
+
+<p><span style='font-size:10.0pt'>When the Program is made available in source
+code form:</span> </p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>a)
+it must be made available under this Agreement; and </span></p>
+
+<p class=MsoNormal style='margin-left:.5in'><span style='font-size:10.0pt'>b) a
+copy of this Agreement must be included with each copy of the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>Contributors may not remove or alter any
+copyright notices contained within the Program. </span></p>
+
+<p><span style='font-size:10.0pt'>Each Contributor must identify itself as the
+originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution. </span></p>
+
+<p><b><span style='font-size:10.0pt'>4. COMMERCIAL DISTRIBUTION</span></b> </p>
+
+<p><span style='font-size:10.0pt'>Commercial distributors of software may
+accept certain responsibilities with respect to end users, business partners
+and the like. While this license is intended to facilitate the commercial use
+of the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes the
+Program in a commercial product offering, such Contributor (&quot;Commercial
+Contributor&quot;) hereby agrees to defend and indemnify every other
+Contributor (&quot;Indemnified Contributor&quot;) against any losses, damages and
+costs (collectively &quot;Losses&quot;) arising from claims, lawsuits and other
+legal actions brought by a third party against the Indemnified Contributor to
+the extent caused by the acts or omissions of such Commercial Contributor in
+connection with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In order
+to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor
+to control, and cooperate with the Commercial Contributor in, the defense and
+any related settlement negotiations. The Indemnified Contributor may participate
+in any such claim at its own expense.</span> </p>
+
+<p><span style='font-size:10.0pt'>For example, a Contributor might include the
+Program in a commercial product offering, Product X. That Contributor is then a
+Commercial Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance claims and
+warranties are such Commercial Contributor's responsibility alone. Under this
+section, the Commercial Contributor would have to defend claims against the
+other Contributors related to those performance claims and warranties, and if a
+court requires any other Contributor to pay any damages as a result, the
+Commercial Contributor must pay those damages.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>5. NO WARRANTY</span></b> </p>
+
+<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
+AGREEMENT, THE PROGRAM IS PROVIDED ON AN &quot;AS IS&quot; BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,
+WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and distributing the
+Program and assumes all risks associated with its exercise of rights under this
+Agreement , including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs or
+equipment, and unavailability or interruption of operations. </span></p>
+
+<p><b><span style='font-size:10.0pt'>6. DISCLAIMER OF LIABILITY</span></b> </p>
+
+<p><span style='font-size:10.0pt'>EXCEPT AS EXPRESSLY SET FORTH IN THIS
+AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF
+THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF
+THE POSSIBILITY OF SUCH DAMAGES.</span> </p>
+
+<p><b><span style='font-size:10.0pt'>7. GENERAL</span></b> </p>
+
+<p><span style='font-size:10.0pt'>If any provision of this Agreement is invalid
+or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without
+further action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.</span> </p>
+
+<p><span style='font-size:10.0pt'>If Recipient institutes patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with
+other software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the date
+such litigation is filed. </span></p>
+
+<p><span style='font-size:10.0pt'>All Recipient's rights under this Agreement
+shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable
+period of time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive. </span></p>
+
+<p><span style='font-size:10.0pt'>Everyone is permitted to copy and distribute
+copies of this Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The Agreement
+Steward reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement Steward has
+the right to modify this Agreement. The Eclipse Foundation is the initial
+Agreement Steward. The Eclipse Foundation may assign the responsibility to
+serve as the Agreement Steward to a suitable separate entity. Each new version
+of the Agreement will be given a distinguishing version number. The Program
+(including Contributions) may always be distributed subject to the version of
+the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly stated
+in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether
+expressly, by implication, estoppel or otherwise. All rights in the Program not
+expressly granted under this Agreement are reserved.</span> </p>
+
+<p><span style='font-size:10.0pt'>This Agreement is governed by the laws of the
+State of New York and the intellectual property laws of the United States of
+America. No party to this Agreement will bring a legal action under this
+Agreement more than one year after the cause of action arose. Each party waives
+its rights to a jury trial in any resulting litigation.</span> </p>
+
+<p class=MsoNormal></p>
+
+</div>
+
+</body>
+
+</html>
\ No newline at end of file
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/feature.xml b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/feature.xml
new file mode 100755
index 0000000..c42a68d
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/feature.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+      id="org.eclipse.papyrus.interoperability.rpy.tests.feature"
+      label="Papyrus Interoperability Rpy Tests Feature (Incubation)"
+      version="0.7.0.qualifier"
+      provider-name="Eclipse Modeling Project">
+
+   <description>
+      This component tests the import of rpy file (created with IBM Rational Rhapsody software) as UML models.
+   </description>
+
+   <copyright>
+      Copyright (c) 2016 CEA LIST.
+All rights reserved.
+   </copyright>
+
+   <plugin
+         id="org.eclipse.papyrus.interoperability.rpy.tests"
+         download-size="0"
+         install-size="0"
+         version="0.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/license.html b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/license.html
new file mode 100755
index 0000000..c3d34c3
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/license.html
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>April 9, 2014</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+   repository (&quot;Repository&quot;) in software modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
+Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license (&quot;Feature Update License&quot;) during the
+installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager (&quot;Provisioning Technology&quot;) for the purpose of allowing users to install software, documentation, information and/or
+   other materials (collectively &quot;Installable Software&quot;). This capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+       href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   (&quot;Specification&quot;).</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+   in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+   Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur (&quot;Provisioning Process&quot;) in which a user may execute the Provisioning Technology
+       on a machine (&quot;Target Machine&quot;) with the intent of installing, extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+       Software (&quot;Installable Software Agreement&quot;) and such Installable Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+       the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+       indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/pom.xml b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/pom.xml
new file mode 100755
index 0000000..a5211c6
--- /dev/null
+++ b/rpy/features/org.eclipse.papyrus.interoperability.rpy.tests.feature/pom.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.tests.releng</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+		<relativePath>../../../releng/tests/pom.xml</relativePath>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.feature</artifactId>
+	<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+	<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-feature</packaging>
+</project>
\ No newline at end of file
diff --git a/rpy/plugins/.gitkeep b/rpy/plugins/.gitkeep
deleted file mode 100755
index e69de29..0000000
--- a/rpy/plugins/.gitkeep
+++ /dev/null
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.blackboxes/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.blackboxes/pom.xml
new file mode 100644
index 0000000..dd6113f
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.blackboxes/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.blackboxes</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.doc/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.doc/pom.xml
new file mode 100644
index 0000000..2a1a766
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.doc/pom.xml
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.doc</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+	
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.mylyn.docs</groupId>
+				<artifactId>org.eclipse.mylyn.wikitext.core.maven</artifactId>
+				<configuration>
+					<sourceFolder>src/site/mediawiki</sourceFolder>
+					<outputFolder>${project.build.directory}/site/generated-eclipse-help</outputFolder>
+					<copyrightNotice>${help.copyrightNotice}</copyrightNotice>
+					<title>${help.documentTitle}</title>
+					<multipleOutputFiles>false</multipleOutputFiles>
+					<navigationImages>true</navigationImages>
+					<formatOutput>true</formatOutput>
+					<htmlFilenameFormat>$1.html</htmlFilenameFormat>
+					<xmlFilenameFormat>$1-toc.xml</xmlFilenameFormat>
+					<helpPrefix>target/site/generated-eclipse-help</helpPrefix>
+					<stylesheetUrls>
+						<param>styles/main.css</param>
+					</stylesheetUrls>
+				</configuration>
+				<executions>
+					<execution>
+						<goals>
+							<goal>eclipse-help</goal>
+						</goals>
+					</execution>
+				</executions>
+				<dependencies>
+					<dependency>
+						<groupId>org.eclipse.mylyn.docs</groupId>
+						<artifactId>org.eclipse.mylyn.wikitext.mediawiki.core</artifactId>
+						<version>${mylyn.wikitext.version}</version>
+					</dependency>
+				</dependencies>
+			</plugin>
+		</plugins>
+	</build>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.geometry/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.geometry/pom.xml
new file mode 100644
index 0000000..1ac7bed
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.geometry/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.geometry</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel.edit/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel.edit/pom.xml
new file mode 100755
index 0000000..e410740
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel.edit/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.metamodel.edit</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel.editor/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel.editor/pom.xml
new file mode 100755
index 0000000..3121d98
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel.editor/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.metamodel.editor</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel/pom.xml
new file mode 100755
index 0000000..bfc3f15
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.metamodel/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.metamodel</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.parser.ui/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.parser.ui/pom.xml
new file mode 100644
index 0000000..26a38ee
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.parser.ui/pom.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.parser.ui</artifactId>
+	<groupId>org.eclipse.papyrus</groupId>
+	<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+  	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-clean-plugin</artifactId>
+				<configuration>
+					<fileset>
+						<directory>xtend-gen</directory>
+						<includes>
+							<include>**/*</include>
+						</includes>
+						<excludes>
+							<exclude>.gitignore</exclude>
+						</excludes>
+					</fileset>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+				<executions>
+					<execution>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+					</execution>
+				</executions>
+				<configuration>
+					<outputDirectory>xtend-gen</outputDirectory>
+					<testOutputDirectory>${project.build.directory}/xtend-gen/test</testOutputDirectory>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>
\ No newline at end of file
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.parser/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.parser/pom.xml
new file mode 100644
index 0000000..2370b39
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.parser/pom.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.parser</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-clean-plugin</artifactId>
+				<configuration>
+					<fileset>
+						<directory>xtend-gen</directory>
+						<includes>
+							<include>**/*</include>
+						</includes>
+						<excludes>
+							<exclude>.gitignore</exclude>
+						</excludes>
+					</fileset>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+				<executions>
+					<execution>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+					</execution>
+				</executions>
+				<configuration>
+					<outputDirectory>xtend-gen</outputDirectory>
+					<testOutputDirectory>${project.build.directory}/xtend-gen/test</testOutputDirectory>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.toolsmiths.api.discovery/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.toolsmiths.api.discovery/pom.xml
new file mode 100644
index 0000000..d1bed1e
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy.toolsmiths.api.discovery/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.toolsmiths.api.discovery</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/org.eclipse.papyrus.interoperability.rpy/pom.xml b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy/pom.xml
new file mode 100644
index 0000000..8b7f5a2
--- /dev/null
+++ b/rpy/plugins/org.eclipse.papyrus.interoperability.rpy/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-plugin</packaging>
+</project>
diff --git a/rpy/plugins/pom.xml b/rpy/plugins/pom.xml
new file mode 100644
index 0000000..7c79903
--- /dev/null
+++ b/rpy/plugins/pom.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.plugins</artifactId>
+	<packaging>pom</packaging>
+	<parent>
+	    <groupId>org.eclipse.papyrus.interoperability</groupId>
+	    <artifactId>org.eclipse.papyrus.interoperability.releng</artifactId>
+	    <version>1.0.0-SNAPSHOT</version>
+	    <relativePath>../../releng/main/pom.xml</relativePath>
+    </parent>
+	<name>Papyrus Interoperability Rpy Plugins</name>
+	<description>The top container of Rpy Migration plug-ins for the Rpy Interoperability.</description>
+	<version>0.7.0-SNAPSHOT</version>
+
+	<modules>
+		<module>org.eclipse.papyrus.interoperability.rpy.metamodel</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.metamodel.edit</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.metamodel.editor</module>
+		<module>org.eclipse.papyrus.interoperability.rpy</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.blackboxes</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.doc</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.geometry</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.parser</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.parser.ui</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.toolsmiths.api.discovery</module>
+	</modules>
+</project>
\ No newline at end of file
diff --git a/rpy/releng/.project b/rpy/releng/.project
new file mode 100644
index 0000000..63b1857
--- /dev/null
+++ b/rpy/releng/.project
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.releng</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+	</buildSpec>
+	<natures>
+	</natures>
+</projectDescription>
diff --git a/rpy/releng/main/pom.xml b/rpy/releng/main/pom.xml
new file mode 100755
index 0000000..5fb6f01
--- /dev/null
+++ b/rpy/releng/main/pom.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.releng</artifactId>
+	<packaging>pom</packaging>
+	<version>0.7.0-SNAPSHOT</version>
+	<parent>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<artifactId>org.eclipse.papyrus.interoperability.releng</artifactId>
+		<version>1.0.0-SNAPSHOT</version>
+		<relativePath>../../../releng/main/pom.xml</relativePath>
+	</parent>
+	<modules>
+		<module>targetplatform</module>
+	</modules>
+</project>
diff --git a/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/.project b/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/.project
new file mode 100755
index 0000000..0766d76
--- /dev/null
+++ b/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
diff --git a/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen.target b/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen.target
new file mode 100755
index 0000000..48273e6
--- /dev/null
+++ b/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen.target
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?pde version="3.8"?><target name="Tycho Tutorial" sequenceNumber="1465317051">
+<locations>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.gmf.runtime.sdk.feature.group" version="1.10.0.201606071959"/>
+<repository location="http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/releases"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.papyrus.sdk.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sdk.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.toolsmiths.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.toolsmiths.feature.source.feature.group" version="0.0.0"/>
+<repository location="http://download.eclipse.org/modeling/mdt/papyrus/updates/nightly/oxygen/main/"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.papyrus.sysml.diagram.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.diagram.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.modelexplorer.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.modelexplorer.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.nattable.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.nattable.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.properties.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.properties.feature.source.feature.group" version="0.0.0"/>
+<repository location="http://download.eclipse.org/modeling/mdt/papyrus/updates/nightly/oxygen/extra/"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<repository location="http://download.eclipse.org/mylyn/drops/3.21.1/v20161129-2023"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.m2m.qvt.oml.sdk.feature.group" version="3.7.0.v20161102-0315"/>
+<unit id="org.eclipse.m2m.qvt.oml.tools.coverage.feature.group" version="1.2.0.v20161102-0315"/>
+<repository location="http://download.eclipse.org/mmt/qvto/updates/milestones/3.7.0"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.uml2.sdk.feature.group" version="5.2.3.v20170227-0935"/>
+<repository location="http://download.eclipse.org/modeling/mdt/uml2/updates/5.2.x"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.emf.sdk.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.equinox.executable.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.equinox.p2.discovery.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.jdt.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.ocl.uml.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.platform.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.rcp.feature.group" version="0.0.0"/>
+<repository location="http://download.eclipse.org/releases/oxygen"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.gmf.runtime.notation.sdk.feature.group" version="1.10.0.201606071631"/>
+<repository location="http://download.eclipse.org/modeling/gmp/gmf-notation/updates/releases"/>
+</location>
+<location includeMode="planner" includeAllPlatforms="false" includeSource="true" includeConfigurePhase="false" type="InstallableUnit">
+<unit id="org.apache.commons.io" version="2.2.0.v201405211200"/>
+<unit id="org.apache.commons.io.source" version="2.2.0.v201405211200"/>
+<repository id="orbit" location="http://download.eclipse.org/tools/orbit/downloads/drops/R20160520211859/repository"/>
+</location>
+</locations>
+</target>
diff --git a/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/pom.xml b/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/pom.xml
new file mode 100755
index 0000000..93fb4d3
--- /dev/null
+++ b/rpy/releng/main/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.target.parent</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>	
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen</artifactId>
+	<packaging>eclipse-target-definition</packaging>
+	<name>Interoperability Rpy Oxygen Target Definition</name>
+	<description>This plug-in contains the target definition for Papyrus Interoperability Rpy in Oxygen</description>
+</project>
\ No newline at end of file
diff --git a/rpy/releng/main/targetplatform/pom.xml b/rpy/releng/main/targetplatform/pom.xml
new file mode 100755
index 0000000..727c5d2
--- /dev/null
+++ b/rpy/releng/main/targetplatform/pom.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.releng</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.target.parent</artifactId>
+	<packaging>pom</packaging>
+	<version>0.7.0-SNAPSHOT</version>
+
+	<modules>
+		<module>org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen</module>
+	</modules>
+</project>
\ No newline at end of file
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/.project b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/.project
new file mode 100644
index 0000000..3755ddd
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.p2</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/category.xml b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/category.xml
new file mode 100644
index 0000000..9cdf62e
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/category.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<site>
+   <feature url="features/org.eclipse.papyrus.interoperability.rpy.feature_0.7.0.qualifier.jar" id="org.eclipse.papyrus.interoperability.rpy.feature" version="0.7.0.qualifier">
+      <category name="org.eclipse.papyrus.category"/>
+   </feature>
+   <feature url="features/org.eclipse.papyrus.interoperability.rpy.feature.source_0.7.0.qualifier.jar" id="org.eclipse.papyrus.interoperability.rpy.feature.source" version="0.7.0.qualifier">
+      <category name="org.eclipse.papyrus.category"/>
+   </feature>
+   
+   <category-def name="org.eclipse.papyrus.category" label="Papyrus Rpy Interoperability">
+      <description>
+         Papyrus Rpy Interoperability Category
+      </description>
+   </category-def>
+</site>
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/pom.xml b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/pom.xml
new file mode 100644
index 0000000..9107cd3
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/pom.xml
@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.releng</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability</groupId>
+		<version>1.0.0-SNAPSHOT</version>
+		<relativePath>../../../releng/main/pom.xml</relativePath>
+	</parent>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.p2</artifactId>
+	<packaging>eclipse-repository</packaging>
+	<pluginRepositories>
+		<pluginRepository>
+			<id>jboss-public-repository-group</id>
+			<name>JBoss Public Repository Group</name>
+			<url>http://repository.jboss.org/nexus/content/groups/public/</url>
+		</pluginRepository>
+	</pluginRepositories>
+
+	<build>
+		<plugins>
+			<plugin>
+				<!-- https://github.com/jbosstools/jbosstools-maven-plugins/wiki -->
+				<groupId>org.jboss.tools.tycho-plugins</groupId>
+				<artifactId>repository-utils</artifactId>
+				<version>0.23.2</version>
+				<executions>
+					<execution>
+						<id>generate-facade</id>
+						<phase>package</phase>
+						<goals>
+							<goal>generate-repository-facade</goal>
+						</goals>
+						<configuration>
+							<symbols>
+								<update.site.name>Papyrus Interoperability</update.site.name>
+								<update.site.description>Use this URL in Eclipse to install
+									Papyrus Interoperability</update.site.description>
+								<update.site.version>${project.version}</update.site.version>
+								<project.website>https://hudson.eclipse.org/papyrus/view/Interoperability/job/papyrus-interoperability-website/ws/site-staging/index.html</project.website>
+								<project.issues>${project.issueManagement.url}</project.issues>
+								<eclipse.target>${eclipse.targetrelease}</eclipse.target>
+								<update.site.nightly>https://hudson.eclipse.org/papyrus/view/Interoperability/job/papyrus-interoperability-rpy-oxygen/ws/releng/org.eclipse.papyrus.interoperability.rpy.p2/target/repository/</update.site.nightly>
+							</symbols>
+							<associateSites>
+								<site>https://hudson.eclipse.org/papyrus/view/Interoperability/job/papyrus-interoperability-website/ws/site-staging/index.html</site>
+							</associateSites>
+							<siteTemplateFolder>siteTemplate</siteTemplateFolder>
+							<p2StatsUrl>http://download.eclipse.org/stats</p2StatsUrl>
+						</configuration>
+					</execution>
+				</executions>
+				<dependencies>
+					<dependency>
+						<groupId>org.eclipse.tycho</groupId>
+						<artifactId>tycho-packaging-plugin</artifactId>
+						<version>${tycho-version}</version>
+					</dependency>
+				</dependencies>
+			</plugin>
+		</plugins>
+	</build>
+	<description>This plugin defines the update site of Papyrus Interoperability Rpy plugins and feature.</description>
+</project>
\ No newline at end of file
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/publish.README b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/publish.README
new file mode 100644
index 0000000..66b977d
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/publish.README
@@ -0,0 +1,3 @@
+The publish.sh script may be used to publish the build results (update site). The script may be called
+without parameters and prompts for everything it requires for publishing an update site, or it may be 
+invoked with respective command line parameters.
\ No newline at end of file
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/publish.sh b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/publish.sh
new file mode 100644
index 0000000..c56ae8f
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/publish.sh
@@ -0,0 +1,403 @@
+#!/bin/sh
+#Based upon Gef4 publish.sh script
+
+#causes the shell to exit if any subcommand or pipeline returns a non-zero status.
+#set -e
+
+# Script may take 10-11 command line parameters:
+# $1: Hudson job name: <name>
+# $2: Hudson build id: <id>
+# $3: Build type: i(ntegration), s(table), r(elease)
+# $4: Whether to promote to an update-site: (y)es, (n)o
+# $5: Whether to merge the site with an existing one: (y)es, (n)o
+# $6: Whether to generate drop files: (y)es, (n)o
+# $7: The release label used to label the drop files and (nested) update site, e.g. 3.10.0 or 3.10.1
+# $8: The eclipse target version, e.g. mars or neon
+# $9: Whether to generate rcp files: (y)es, (n)o
+# $10: Papyrus component 
+# $11: An optional release label suffix to be appended to drop files and (nested) update site name, e.g. M1, RC1 
+
+#The publish.sh script may be used to publish the build results (update site and drop files and rcp). The script may be called
+#without parameters and prompts for everything it requires for publishing an update site, or it may be 
+#invoked with respective command line parameters.
+if [ $# -eq 10 -o $# -eq 11  ];
+then
+	jobName=$1
+	echo "jobName: $jobName"
+	buildId=$2
+	echo "buildId: $buildId"
+	buildType=$3
+	echo "buildType: $buildType"
+	site=$4
+	echo "site: $site"
+	merge=$5
+	echo "merge: $merge"
+	dropFiles=$6
+	echo "dropFiles: $dropFiles"
+	releaseLabel=$7	
+	echo "releaseLabel: $releaseLabel"
+	eclipseTarget=$8	
+	echo "eclipseTarget: $eclipseTarget"
+	rcpFiles=$9	
+	echo "rcpFiles: $rcpFiles"
+	component=${10}	
+	echo "component: $component"
+	if [ -n "${11}" ];
+	then
+		releaseLabelSuffix=${11}
+		echo "releaseLabelSuffix: $releaseLabelSuffix"
+	fi
+else
+	if [ $# -ne 0 ];
+	then
+		exit 1
+	fi
+fi
+
+#The root url that enables to find the job with ${hudsonJobRootUrl}/$jobName/$buildId
+hudsonJobRootUrl="https://hudson.eclipse.org/papyrus/job/"
+
+#The localization of the local build target update site
+targetUpdateSite="archive/releng/org.eclipse.papyrus.${component}.p2/target/repository"
+targetRCPRoot="archive/releng/org.eclipse.papyrus.${component}.product/target/products/org.eclipse.papyrus.${component}.product"
+
+#The feature to parse to retrieve the qualifierversion
+feature2Parse4QualifierVersion="org.eclipse.papyrus.${component}.feature"
+
+#The specific localization
+hudsonRoot="/home/data/httpd/download.eclipse.org/"
+
+remoteUpdateSiteRoot="modeling/mdt/papyrus/components/${component}"
+remoteDropDir=${hudsonRoot}/${remoteUpdateSiteRoot}/downloads/drops
+remoteUpdateSite="${hudsonRoot}/${remoteUpdateSiteRoot}/${remoteSite}"
+remoteRcpDir=${hudsonRoot}/${remoteUpdateSiteRoot}/downloads/rcps
+
+
+
+if [ -z "$jobName" ];
+then
+	echo -n "Please enter the name of the Hudson job you want to promote:"
+	read jobName
+fi
+
+if [ -z "$buildId" ];
+then
+	for i in $( find ~/.hudson/jobs/$jobName/builds -type l | sed 's!.*/!!' | sort)
+	do
+		echo -n "$i, "
+	done
+	echo "lastStable, lastSuccessful"
+	echo -n "Please enter the id of the $jobName build you want to promote:"
+	read buildId
+fi
+
+if [ "$buildId" = "lastStable" -o "$buildId" = "lastSuccessful" ];
+then
+	# Reverse lookup the build id (in case lastSuccessful or lastStable was used)
+	for i in $(find ~/.hudson/jobs/$jobName/builds/ -type l)
+	do
+		if [ "$(readlink -f $i)" = "$(readlink -f ~/.hudson/jobs/$jobName/$buildId)" ];
+		then
+			buildId=${i##*/}
+		fi
+	done
+	echo "Reverse lookup (lastStable/lastSuccessful) yielded buildId: $buildId"
+fi
+
+# Determine the local update site we want to publish to
+jobDir=$(readlink -f ~/.hudson/jobs/${jobName}/builds/${buildId})
+if [ ! -d $jobDir ];
+then
+	echo "The specified buildId does not refer to an existing build: $buildId"
+	exit 1
+fi
+
+
+localUpdateSite=${jobDir}/${targetUpdateSite}
+echo "jobDir=${jobDir}"
+echo "targetUpdateSite=${targetUpdateSite}"
+echo "localUpdateSite=${localUpdateSite}"
+
+localRCPSiteRoot=${jobDir}/${targetRCPRoot}
+echo "localRCPSiteRoot=${localRCPSiteRoot}"
+
+echo "Publishing from local update site: $localUpdateSite"
+
+# Select the build type
+if [ -z "$buildType" ];
+then
+    echo -n "Please select which type of build you want to publish to [i(integration), s(table), r(elease)]: "
+    read buildType
+fi
+echo "Publishing as $buildType build"
+
+# check if we are going to promote to an update-site
+if [ -z "$site" ];
+then
+	echo -n "Do you want to promote to an remote update site? [(y)es, (n)o]:"
+	read site
+fi
+if [ "$site" != y -a "$site" != n ];
+then
+	echo "Parameter site has to be 'y'(es) or 'n'(o) but was: $site"
+    exit 0
+fi
+echo "Promoting to remote update site: $site"
+
+if [ "$site" = y ];
+then
+	# Determine remote update site we want to promote to
+	case $buildType in
+		i|I) remoteSite=integration;;
+		s|S) remoteSite=milestones;;
+		r|R) remoteSite=releases;;
+		*) 
+		echo "Parameter buildType has to be 'i'(ntegration), 's'(stable), or 'r'(elease), but was: $buildType"
+		exit 1 ;;
+	esac
+
+	echo "Publishing to remote update-site: $remoteUpdateSite"
+
+	if [ -d "$remoteUpdateSite" ];
+	then
+		if [ -z "$merge" ];
+		then
+			echo -n "Do you want to merge with the existing update-site? [(y)es, (n)o]:"
+			read merge
+		fi
+		if [ "$merge" != y -a "$merge" != n ];
+		then
+			echo "Parameter merge has to be 'y'(es) or 'n'(o) but was: $merge"
+			exit 1
+		fi
+	else
+		merge=n
+	fi
+	echo "Merging with existing site: $merge"
+fi
+
+# check if we are going to create drop files
+if [ -z "$dropFiles" ];
+then
+	echo -n "Do you want to create drop files? [(y)es, (n)o]:"
+	read dropFiles
+fi
+if [ "$dropFiles" != y -a "$dropFiles" != n ];
+then
+	echo "Parameter dropFiles has to be 'y'(es) or 'n'(o) but was: $dropFiles"
+	exit 1
+fi
+echo "Generating drop files: $dropFiles"
+
+# Determine releaseLabel
+if [ -z "$releaseLabel" ];
+then
+    echo -n "Please enter release label (e.g. 3.10.0, 3.10.1M2):"
+    read releaseLabel
+fi
+
+# Prepare a temp directory
+mkdir -p target
+cd target
+tmpDir="$jobName-publish-tmp"
+rm -fr $tmpDir
+mkdir -p $tmpDir
+cd $tmpDir
+
+# Download and prepare Eclipse SDK, which is needed to merge update site and postprocess repository 
+echo "Downloading eclipse to $PWD"
+
+cp /home/data/httpd/download.eclipse.org/eclipse/downloads/drops4/R-4.5.2-201602121500/eclipse-SDK-4.5.2-linux-gtk-x86_64.tar.gz .
+ls -la
+tar -xzf eclipse-SDK-4.5.2-linux-gtk-x86_64.tar.gz
+cd eclipse
+chmod 700 eclipse
+cd ..
+if [ ! -d "eclipse" ];
+then
+    echo "Failed to download an Eclipse SDK, being needed for provisioning."
+    exit
+fi
+# Prepare Eclipse SDK to provide WTP releng tools (used to postprocess repository, i.e set p2.mirrorsURL property)
+echo "Installing WTP Releng tools"
+./eclipse/eclipse -nosplash --launcher.suppressErrors -clean -debug -application org.eclipse.equinox.p2.director -repository http://download.eclipse.org/webtools/releng/repository/ -installIUs org.eclipse.wtp.releng.tools.feature.feature.group
+# Clean up
+echo "Cleaning up"
+rm eclipse-SDK-4.5.2-linux-gtk-x86_64.tar.gz
+
+# Generate drop files
+if [ "$dropFiles" = y ];
+	then
+	
+	# Prepare local update site (for drop files)
+	mkdir -p update-site
+	cp -R $localUpdateSite/* update-site/
+	echo "Copied $localUpdateSite to local directory update-site."
+	
+	qualifiedVersion=$(find update-site/features/ -maxdepth 1 | grep "${feature2Parse4QualifierVersion}")
+	qualifiedVersion=${qualifiedVersion%.jar}
+    qualifiedVersion=${qualifiedVersion#*_}
+    qualifier=${qualifiedVersion##*.}
+    dropDir="${releaseLabel}/$(echo $buildType | tr '[:lower:]' '[:upper:]')$qualifier"
+    localDropDir=drops/$dropDir
+    echo "Creating drop files in local directory $localDropDir"
+    mkdir -p $localDropDir
+    
+    cd update-site
+    zip -r ../$localDropDir/${component}-Update-${releaseLabel}${releaseLabelSuffix}.zip features plugins artifacts.jar content.jar
+    md5sum ../$localDropDir/${component}-Update-${releaseLabel}${releaseLabelSuffix}.zip > ../$localDropDir/${component}-Update-${releaseLabel}${releaseLabelSuffix}.zip.md5
+    echo "Created ${component}-Update-Site-${releaseLabel}${releaseLabelSuffix}.zip" 
+    cd ..  
+
+    # Cleanup local update site (for drop files generation)
+	rm -fr update-site
+
+	#generating build.cfg file to be referenced from downloads web page
+	echo "generating build.cfg file to be referenced from downloads web page"
+    echo "hudson.job.name=$jobName" > $localDropDir/build.cfg
+    echo "hudson.job.id=$buildId (${jobDir##*/})" >> $localDropDir/build.cfg
+    echo "hudson.job.url= ${hudsonJobRootUrl}/$jobName/$buildId" >> $localDropDir/build.cfg
+    
+	mkdir -p $remoteDropDir
+    cp -R $localDropDir/* $remoteDropDir/
+         
+fi
+
+# Generate RCP files
+if [ "$rcpFiles" = y ];
+	then
+	
+	# Prepare local rcp site (for rcp files)
+	mkdir -p rcp-site
+	cp ${localRCPSiteRoot}-linux.gtk.x86_64.zip rcp-site/org.eclipse.papyrus.${component}.product-${releaseLabel}-${releaseLabelSuffix}-linux.gtk.x86_64.zip
+	echo "Copied ${localRCPSiteRoot}-linux.gtk.x86_64.zip to local directory rcp-site."
+	
+	qualifiedVersion=$(find update-site/features/ -maxdepth 1 | grep "${feature2Parse4QualifierVersion}")
+	qualifiedVersion=${qualifiedVersion%.jar}
+    qualifiedVersion=${qualifiedVersion#*_}
+    qualifier=${qualifiedVersion##*.}
+    dropDir="${releaseLabel}/$(echo $buildType | tr '[:lower:]' '[:upper:]')$qualifier"
+
+	localRcpDir=rcps/$dropDir
+    echo "Creating rcp files in local directory $localRcpDir"
+    mkdir -p $localRcpDir
+    
+    cd rcp-site
+    cp * ../$localRcpDir/
+    
+    echo "Created org.eclipse.papyrus.${component}.product-${releaseLabel}-${releaseLabelSuffix}-linux.gtk.x86_64.zip in ../$localRcpDir/" 
+    cd ..  
+
+    # Cleanup local update site (for drop files generation)
+	rm -fr rcp-site
+
+	mkdir -p ${remoteRcpDir}/${eclipseTarget}/${releaseLabel}
+    cp -R $localRcpDir/* $remoteRcpDir/${eclipseTarget}/${releaseLabel}/
+       
+fi
+
+if [ "$site" = y ];
+then
+	mkdir -p update-site
+	updateSiteLabel=${releaseLabel}${releaseLabelSuffix}_${jobName}_${buildId}
+	# Prepare composite local update site (transfer into composite if needed)
+	if [ "$merge" = y ];
+	then
+		# check if the remote site is a composite update site
+		echo "Merging existing site into local one."
+		if [ -e "$remoteUpdateSite/compositeArtifacts.xml" ];
+		then
+			cp -R $remoteUpdateSite/* update-site/
+		else
+			mkdir -p update-site/pre_${updateSiteLabel}
+			cp -R $remoteUpdateSite/* update-site/pre_${updateSiteLabel}/
+		fi
+	else 
+		echo "Skipping merge operation."    
+	fi
+	# move local update site below composite one
+	mkdir -p update-site/${updateSiteLabel}
+	cp -R $localUpdateSite/* update-site/${updateSiteLabel}/
+    	
+	cd update-site
+	children=$(find . -maxdepth 1 -type d -print | wc -l)
+	children=$(($children-1))
+	timestamp=$(date +%s000)
+
+content="
+<?xml version='1.0' encoding='UTF-8'?>
+<?compositeMetadataRepository version='1.0.0'?>
+<repository name='${component} ${remoteSite}' type='org.eclipse.equinox.internal.p2.metadata.repository.CompositeMetadataRepository' version='1.0.0'>
+<properties size='1'>
+<property name='p2.timestamp' value='${timestamp}'/>
+</properties>
+<children size='${children}'>
+$(
+for file in *; do
+  if [ -d $file ]; then
+printf "<child location='${file}'/>"
+  fi
+done
+)
+</children>
+</repository>
+"
+	echo $content > compositeContent.xml
+
+artifact="
+<?xml version='1.0' encoding='UTF-8'?>
+<?compositeArtifactRepository version='1.0.0'?>
+<repository name='${component} ${remoteSite}' type='org.eclipse.equinox.internal.p2.artifact.repository.CompositeArtifactRepository' version='1.0.0'>
+<properties size='1'>
+<property name='p2.timestamp' value='${timestamp}'/>
+</properties>
+<children size='${children}'>
+$(
+for file in *; do
+  if [ -d $file ]; then
+printf "<child location='${file}'/>"
+  fi
+done
+)
+</children>
+</repository>
+"
+	echo $artifact > compositeArtifacts.xml
+
+	cd ..
+
+	# Ensure p2.mirrorURLs property is used in update site
+	echo "Updating p2.mirrorURLs property."
+	./eclipse/eclipse -nosplash --launcher.suppressErrors -clean -debug -application org.eclipse.wtp.releng.tools.addRepoProperties -vmargs -DartifactRepoDirectory=$PWD/update-site/${updateSiteLabel} -Dp2MirrorsURL="http://www.eclipse.org/downloads/download.php?format=xml&file=/${remoteUpdateSiteRoot}/${remoteSite}/${updateSiteLabel}"
+
+	# Create p2.index file
+	if [ ! -e "update-site/p2.index" ];
+	then
+		echo "Creating p2.index file."
+		echo "version = 1" > update-site/p2.index
+		echo "metadata.repository.factory.order=compositeContent.xml,\!" >> update-site/p2.index
+		echo "artifact.repository.factory.order=compositeArtifacts.xml,\!" >> update-site/p2.index
+	fi
+
+	# Backup then clean remote update site
+	echo "Creating backup of remote update site."
+	if [ -d "$remoteUpdateSite" ];
+	then
+		if [ -d BACKUP ];
+		then
+			rm -fr BACKUP
+		fi
+		mkdir BACKUP
+		cp -R $remoteUpdateSite/* BACKUP/
+		rm -fr $remoteUpdateSite
+	fi
+
+	echo "Publishing contents of local update-site directory to remote update site $remoteUpdateSite"
+	mkdir -p $remoteUpdateSite
+	cp -R update-site/* $remoteUpdateSite/
+fi
+
+# Clean up
+echo "Cleaning up"
+rm -fr eclipse
+rm -fr update-site
\ No newline at end of file
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/index.html b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/index.html
new file mode 100644
index 0000000..9674e71
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/index.html
@@ -0,0 +1,113 @@
+<html>
+<head>
+<title>${update.site.name} Update Site: ${update.site.version}</title>
+<link rel="stylesheet" type="text/css" href="web/site.css">
+</head>
+<body marginheight="0" marginwidth="0" leftmargin="0" topmargin="0">
+<center>
+<table cellspacing="0" cellpadding="0" class="table">
+	<tr>
+		<td colspan="3" class="td_header">&nbsp;</td>
+	</tr>
+	<tr>
+		<td>&#160;&#160;&#160;&#160;&#160;&#160;</td>
+		<td>&#160;&#160;&#160;&#160;&#160;&#160;</td>
+		<td>&#160;&#160;&#160;&#160;&#160;&#160;</td>
+	</tr>
+	<tr>
+		<td>&#160;&#160;&#160;&#160;&#160;&#160;</td>
+		<td>
+		<h2 class="title">${update.site.name} Update Site</h2>
+		<table width="100%">
+			<tr class="header">
+				<td class="sub-header" width="100%"><span>Latest Build: ${update.site.version}</span></td>
+			</tr>
+
+			<tr class="light-row" style="height: 30px">
+				<td class="bodyText">
+				<p class="bodyText">This is the <b>${update.site.description}</b>
+				Update Site for ${update.site.name}.
+								<blockquote style="border: 1px dashed #1778be; padding: 2px">
+									<ol>
+										<li>To install
+											from this site, start up Eclipse ${eclipse.target}, then do:
+											<ul>
+												<code><strong>Help > Install New Software... ></strong></code>
+											</ul>
+										</li>
+										<li>Copy this site's URL into Eclipse, and hit Enter.</li>
+										<li>When the site loads, select the features to install,
+											or click the <code><strong>Select All</strong></code> button.</li>
+										<li>To properly resolve all dependencies, check
+										<ul><code><strong>[x] Contact all update sites during install to find required software</strong></code></ul>
+
+										<li>Click <code><strong>Next</strong></code>, agree to the license
+											terms, and install.</li>
+
+										<p class="bodyText">
+											You can also download SysML 1.4 as individual zips for
+											offline installation. See <a class="link"
+												href="https://hudson.eclipse.org/papyrus/view/Sysml/job/papyrus-sysml-nightly-build/ws/releng/org.eclipse.papyrus.sysml14.p2/target/repository/*zip*/repository.zip">SysML 1.4 product
+												Downloads</a>.<br />
+										</p>
+									</ol>
+								</blockquote>
+							</td>
+						</tr>
+		</table>
+		</td>
+		<td>&#160;&#160;&#160;&#160;&#160;&#160;</td>
+	</tr>
+	<tr>
+		<td></td>
+		<td>
+	        ${site.contents}
+		</td>
+		<td></td>
+	</tr>
+	<tr>
+		<td></td>
+		<td>
+		<table width="100%">
+			<tr class="header">
+				<td class="sub-header" width="100%"><span> More informations</span></td>
+			</tr>
+			<tr class="light-row" style="height: 30px">
+				<td class="bodyText">
+				<h4>Documentation</h4>
+				<p class="bodyText">You can check here the web site <a href="${project.website}">documentation</a>.</p>
+				<br />
+
+				</td>
+			</tr>
+
+			<tr class="dark-row" style="height: 30px">
+				<td class="bodyText">
+				<h4>Report issues</h4>
+
+				<p>We'd greatly
+				appreciate the assistance in testing and <a
+					href="${project.issues}">reporting of
+				issues in our issue tracker</a>.</p><br/>
+
+				</td>
+			</tr>
+
+			<tr class="light-row" style="height: 30px">
+				<td class="bodyText">
+				<h4>Nightly Builds</h4>
+
+				<p>The <a
+					href="${update.site.nightly}">bleeding
+				edge</a> contains the latest and greatest new features, but nothing is
+				stable or guaranteed - yet. If you're using a Milestone and need a
+				fix, you can update to the latest Nightly, or wait for the next
+				Milestone.</p><br/>
+				</td>
+			</tr>
+		</table>
+		</td>
+	</tr>
+</table>
+</center>
+</html>
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/web/img/rpy-banner.png b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/web/img/rpy-banner.png
new file mode 100644
index 0000000..2797993
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/web/img/rpy-banner.png
Binary files differ
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/web/site.css b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/web/site.css
new file mode 100644
index 0000000..cb32374
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/web/site.css
@@ -0,0 +1,82 @@
+<
+STYLE type ="text/css">td.spacer {
+	padding-bottom: 10px;
+	padding-top: 10px;
+}
+
+.title {
+	font-family: sans-serif;
+	color: #1778be;
+}
+
+.table {
+	margin-top: 0px;
+	margin-left: 0px;
+	width: 920px;
+}
+
+.bodyText {
+	font-family: sans-serif;
+	font-size: 9pt;
+	color: #000000;
+	width: 100%
+}
+
+.sub-header {
+	background: url('http://download.eclipse.org/eclipse.org-common/themes/solstice/public/images/template/breadcrumbs-large-bg.jpg') center #1b1732;
+    background-size: 100%;
+    color: #fff;
+    text-align: center;
+}
+
+.log-text {
+	font-family: sans-serif;
+	font-style: normal;
+	font-weight: lighter;
+	font-size: 8pt;
+	color: black;
+}
+
+.big-header {
+	font-family: sans-serif;
+	font-style: normal;
+	font-weight: bold;
+	font-size: 9pt;
+	color: white;
+	border-top: 10px solid white;
+}
+
+.light-row {
+	background: #FFFFFF
+}
+
+.dark-row {
+	background: #EEEEEE
+}
+
+.header {
+	background: #445562
+}
+
+#indent {
+	word-wrap: break-word;
+	width: 300px;
+	text-indent: 10px;
+}
+
+.link {
+	color: #187dc6;
+}
+
+.td_header {
+	background: url("img/rpy-banner.png") 0 no-repeat;
+	height: 100px;
+}
+
+.column-header {
+	font-size:small;
+}
+
+</
+STYLE
+>
\ No newline at end of file
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/xslt/site.properties.xsl b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/xslt/site.properties.xsl
new file mode 100644
index 0000000..127c98d
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/xslt/site.properties.xsl
@@ -0,0 +1,20 @@
+<xsl:stylesheet version="2.0"
+	xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xalan="http://xml.apache.org/xalan"
+	xmlns:saxon="http://saxon.sf.net/" xmlns="http://www.w3.org/1999/xhtml"
+	extension-element-prefixes="saxon">
+	<xsl:output method="text" indent="yes" />
+	<xsl:template match="/site">
+		<xsl:for-each select="category-def">
+			<xsl:sort select="@name" />
+			<xsl:variable name="catg"><xsl:value-of select="@name"/></xsl:variable>
+# 
+<xsl:value-of select="$catg" />.category.features = \
+<xsl:for-each select="//feature">
+				<xsl:sort select="@id" />
+				<xsl:if test="count(./category[contains(@name,$catg)])>0"><xsl:value-of select="@id" />,
+</xsl:if>
+			</xsl:for-each>
+		</xsl:for-each>
+# 
+	</xsl:template>
+</xsl:stylesheet>
diff --git a/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/xslt/site.xsl b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/xslt/site.xsl
new file mode 100644
index 0000000..235f683
--- /dev/null
+++ b/rpy/releng/org.eclipse.papyrus.interoperability.rpy.p2/siteTemplate/xslt/site.xsl
@@ -0,0 +1,128 @@
+<xsl:stylesheet version="2.0"
+	xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xalan="http://xml.apache.org/xalan"
+	xmlns:saxon="http://saxon.sf.net/" xmlns="http://www.w3.org/1999/xhtml"
+	extension-element-prefixes="saxon">
+	<xsl:output method="html" indent="yes" />
+	<xsl:template match="/site">
+		<table cellspacing="2" cellpadding="0" border="0">
+			<xsl:if test="count(feature[contains(@id,'papyrus')])>0">
+				<tr style="background-color:#DDDDDD">
+					<th class="column-header">Feature</th>
+					<th class="column-header">Version</th>
+					<th class="column-header">Feature Categor(ies)</th>
+				</tr>
+				<!-- papyrus features -->
+				<xsl:for-each select="feature[contains(@id,'papyrus')]">
+					<xsl:sort select="@id" />
+					<xsl:variable name="rowCol">
+						<xsl:if test="position() mod 2 = 1">
+							#EEEEEE
+						</xsl:if>
+						<xsl:if test="position() mod 2 = 0">
+							#FFFFFF
+						</xsl:if>
+					</xsl:variable>
+
+					<tr style="background-color:{$rowCol}">
+						<td class="rowLine">
+							<a href="{@url}" style="font-size:x-small">
+								<xsl:value-of select="@id" />
+							</a>
+						</td>
+						<td>
+							<span style="font-size:x-small">
+								<xsl:value-of select="@version" />
+							</span>
+						</td>
+						<td>
+							<xsl:choose>
+								<xsl:when test="category">
+									<xsl:for-each select="category">
+										<span style="font-size:x-small">
+											|
+											<xsl:value-of select="@name" />
+										</span>
+									</xsl:for-each>
+								</xsl:when>
+							</xsl:choose>
+						</td>
+					</tr>
+				</xsl:for-each>
+			</xsl:if>
+			<!-- xsl:if test="count(feature[not(contains(@id,'papyrus'))])>0">
+				<tr style="background-color:#DDDDDD">
+					<th class="column-header">Feature</th>
+					<th class="column-header">Version</th>
+					<th class="column-header">Feature Categor(ies)</th>
+				</tr>
+				<xsl:for-each select="feature[not(contains(@id,'papyrus'))]">
+					<xsl:sort select="@id" />
+					<xsl:variable name="rowCol">
+						<xsl:if test="position() mod 2 = 1">
+							#EEEEEE
+						</xsl:if>
+						<xsl:if test="position() mod 2 = 0">
+							#FFFFFF
+						</xsl:if>
+					</xsl:variable>
+
+					<tr style="background-color:{$rowCol}">
+						<td class="rowLine">
+							<a href="{@url}" style="font-size:x-small">
+								<xsl:value-of select="@id" />
+							</a>
+						</td>
+						<td>
+							<span style="font-size:x-small">
+								<xsl:value-of select="@version" />
+							</span>
+						</td>
+						<td>
+							<xsl:choose>
+								<xsl:when test="category">
+									<xsl:for-each select="category">
+										<span style="font-size:x-small">
+											|
+											<xsl:value-of select="@name" />
+										</span>
+									</xsl:for-each>
+								</xsl:when>
+							</xsl:choose>
+						</td>
+					</tr>
+				</xsl:for-each>
+			</xsl:if-->
+
+			<tr style="background-color:#DDDDDD">
+				<th class="column-header">Feature</th>
+				<th class="column-header">Version</th>
+				<th class="column-header">Feature Categor(ies)</th>
+			</tr>
+			<tr style="background-color:#EEEEEE">
+				<td class="rowLine" colspan="1">
+					<a href="artifacts.jar" style="font-size:x-small">artifacts.jar</a>
+					::
+					<a href="content.jar" style="font-size:x-small">content.jar</a>
+				</td>
+				<td class="rowLine" colspan="1">
+					::
+					<a href="plugins/" style="font-size:x-small">plugins</a>
+				<xsl:if test="count(feature)>0">
+					::
+					<a href="features/" style="font-size:x-small">features</a>
+				</xsl:if>
+				</td>
+				<td class="rowLine" colspan="1">
+				<xsl:if test="count(feature[contains(@id,'papyrus')])>0">
+					<a href="category.xml" style="font-size:x-small">category.xml</a>
+					::
+					<a href="buildinfo.json" style="font-size:x-small">buildinfo.json</a>
+					::
+					<a href="site.properties" style="font-size:x-small">site.properties</a>
+				</xsl:if>
+				</td>
+			</tr>
+		</table>
+		<br />
+	</xsl:template>
+</xsl:stylesheet>
diff --git a/rpy/releng/tests/pom.xml b/rpy/releng/tests/pom.xml
new file mode 100755
index 0000000..ea88730
--- /dev/null
+++ b/rpy/releng/tests/pom.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+		<artifactId>org.eclipse.papyrus.interoperability.tests.releng</artifactId>
+		<version>1.0.0-SNAPSHOT</version>
+		<relativePath>../../../releng/tests/pom.xml</relativePath>
+	</parent>
+	<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.releng</artifactId>
+	<version>0.7.0-SNAPSHOT</version>
+	<packaging>pom</packaging>
+	<modules>
+		<module>targetplatform</module>
+	</modules>
+</project>
diff --git a/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/.project b/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/.project
new file mode 100644
index 0000000..35b6e87
--- /dev/null
+++ b/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.papyrus.interoperability.rpy.tests.targetplatform.oxygen</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
diff --git a/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen.target b/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen.target
new file mode 100644
index 0000000..4177aaf
--- /dev/null
+++ b/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen.target
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?pde version="3.8"?><target name="Tycho Tutorial" sequenceNumber="1465317046">
+<locations>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.gmf.runtime.sdk.feature.group" version="1.10.0.201606071959"/>
+<repository location="http://download.eclipse.org/modeling/gmp/gmf-runtime/updates/releases"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<repository location="http://download.eclipse.org/mylyn/drops/3.21.1/v20161129-2023"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.uml2.sdk.feature.group" version="5.2.3.v20170227-0935"/>
+<repository location="http://download.eclipse.org/modeling/mdt/uml2/updates/5.2.x"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.papyrus.sysml.diagram.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.diagram.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.modelexplorer.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.modelexplorer.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.nattable.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.nattable.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.properties.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sysml.properties.feature.source.feature.group" version="0.0.0"/>
+<repository location="http://download.eclipse.org/modeling/mdt/papyrus/updates/nightly/oxygen/extra/"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.gmf.runtime.notation.sdk.feature.group" version="1.10.0.201606071631"/>
+<repository location="http://download.eclipse.org/modeling/gmp/gmf-notation/updates/releases"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.m2m.qvt.oml.sdk.feature.group" version="3.7.0.v20161102-0315"/>
+<unit id="org.eclipse.m2m.qvt.oml.tools.coverage.feature.group" version="1.2.0.v20161102-0315"/>
+<repository location="http://download.eclipse.org/mmt/qvto/updates/milestones/3.7.0"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.papyrus.sdk.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.sdk.feature.source.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.toolsmiths.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.toolsmiths.feature.source.feature.group" version="0.0.0"/>
+<repository location="http://download.eclipse.org/modeling/mdt/papyrus/updates/nightly/oxygen/main/"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.papyrus.dev.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.papyrus.dev.feature.source.feature.group" version="0.0.0"/>
+<repository location="https://hudson.eclipse.org/papyrus/view/Oxygen%20(Master)/job/Papyrus-Master-Developer/lastSuccessfulBuild/artifact/repository/"/>
+</location>
+<location includeAllPlatforms="false" includeConfigurePhase="false" includeMode="planner" includeSource="true" type="InstallableUnit">
+<unit id="org.eclipse.emf.sdk.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.equinox.executable.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.equinox.p2.discovery.feature.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.jdt.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.ocl.uml.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.platform.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.rcp.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.emf.compare.diagram.papyrus.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.emf.compare.ide.ui.feature.group" version="0.0.0"/>
+<unit id="org.eclipse.emf.compare.uml2.feature.group" version="0.0.0"/>
+<repository location="http://download.eclipse.org/releases/oxygen"/>
+</location>
+<location includeMode="planner" includeAllPlatforms="false" includeSource="true" includeConfigurePhase="false" type="InstallableUnit">
+<unit id="org.apache.commons.io" version="2.2.0.v201405211200"/>
+<unit id="org.apache.commons.io.source" version="2.2.0.v201405211200"/>
+<repository id="orbit" location="http://download.eclipse.org/tools/orbit/downloads/drops/R20160520211859/repository"/>
+</location>
+</locations>
+</target>
diff --git a/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/pom.xml b/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/pom.xml
new file mode 100644
index 0000000..806249e
--- /dev/null
+++ b/rpy/releng/tests/targetplatform/org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen/pom.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.target.parent</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>	
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen</artifactId>
+	<packaging>eclipse-target-definition</packaging>
+	<name>Interoperability Rpy Oxygen Target Definition</name>
+	<description>This plug-in contains the target definition for Papyrus Interoperability Rpy in Oxygen</description>
+</project>
\ No newline at end of file
diff --git a/rpy/releng/tests/targetplatform/pom.xml b/rpy/releng/tests/targetplatform/pom.xml
new file mode 100755
index 0000000..0a5fa64
--- /dev/null
+++ b/rpy/releng/tests/targetplatform/pom.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.releng</artifactId>
+		<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.target.parent</artifactId>
+	<packaging>pom</packaging>
+	<version>0.7.0-SNAPSHOT</version>
+
+	<modules>
+		<module>org.eclipse.papyrus.interoperability.rpy.targetplatform.oxygen</module>
+	</modules>
+</project>
\ No newline at end of file
diff --git a/rpy/tests/.gitkeep b/rpy/tests/.gitkeep
deleted file mode 100755
index e69de29..0000000
--- a/rpy/tests/.gitkeep
+++ /dev/null
diff --git a/rpy/tests/org.eclipse.papyrus.interoperability.rpy.sysml.tests/pom.xml b/rpy/tests/org.eclipse.papyrus.interoperability.rpy.sysml.tests/pom.xml
new file mode 100644
index 0000000..8747e62
--- /dev/null
+++ b/rpy/tests/org.eclipse.papyrus.interoperability.rpy.sysml.tests/pom.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.plugins</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.sysml.tests</artifactId>
+	<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-test-plugin</packaging>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>tycho-surefire-plugin</artifactId>
+				<version>${tycho-version}</version>
+				<configuration>
+					<useUIHarness>true</useUIHarness>
+					<useUIThread>true</useUIThread>
+					<testFailureIgnore>true</testFailureIgnore>
+					<product>org.eclipse.sdk.ide</product>
+					<!-- If a specific <argLine> is required here, make sure to include JaCoCo parameters (See parent pom, Bug 478170) -->
+					<skipTests>${skipAllTests}</skipTests>
+					<testClass>org.eclipse.papyrus.interoperability.rpy.sysml.tests.tests.AllTests</testClass>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>target-platform-configuration</artifactId>
+				<version>${tycho-version}</version>
+			</plugin>
+		</plugins>
+	</build>
+</project>
\ No newline at end of file
diff --git a/rpy/tests/org.eclipse.papyrus.interoperability.rpy.tests/pom.xml b/rpy/tests/org.eclipse.papyrus.interoperability.rpy.tests/pom.xml
new file mode 100755
index 0000000..a6342a6
--- /dev/null
+++ b/rpy/tests/org.eclipse.papyrus.interoperability.rpy.tests/pom.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+		<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.plugins</artifactId>
+		<version>0.7.0-SNAPSHOT</version>
+	</parent>
+	<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+	<artifactId>org.eclipse.papyrus.interoperability.rpy.tests</artifactId>
+	<version>0.7.0-SNAPSHOT</version>
+	<packaging>eclipse-test-plugin</packaging>
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>tycho-surefire-plugin</artifactId>
+				<version>${tycho-version}</version>
+				<configuration>
+					<useUIHarness>true</useUIHarness>
+					<useUIThread>true</useUIThread>
+					<testFailureIgnore>true</testFailureIgnore>
+					<product>org.eclipse.sdk.ide</product>
+					<!-- If a specific <argLine> is required here, make sure to include JaCoCo parameters (See parent pom, Bug 478170) -->
+					<skipTests>${skipAllTests}</skipTests>
+					<testClass>org.eclipse.papyrus.interoperability.rpy.tests.AllTests</testClass>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>target-platform-configuration</artifactId>
+				<version>${tycho-version}</version>
+			</plugin>
+		</plugins>
+	</build>
+</project>
\ No newline at end of file
diff --git a/rpy/tests/pom.xml b/rpy/tests/pom.xml
new file mode 100644
index 0000000..dad176a
--- /dev/null
+++ b/rpy/tests/pom.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project>
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+	    <groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+	    <artifactId>org.eclipse.papyrus.interoperability.tests.releng</artifactId>
+	    <version>1.0.0-SNAPSHOT</version>
+	    <relativePath>../../releng/tests/pom.xml</relativePath>
+    </parent>
+  	<groupId>org.eclipse.papyrus.interoperability.tests</groupId>
+  	<artifactId>org.eclipse.papyrus.interoperability.rpy.tests.plugins</artifactId>
+  	<version>0.7.0-SNAPSHOT</version>
+	<packaging>pom</packaging>
+	<description>The top container of Rpy migration tests plug-ins for the Interoperability.</description>
+
+	<modules>
+		<module>org.eclipse.papyrus.interoperability.rpy.sysml.tests</module>
+		<module>org.eclipse.papyrus.interoperability.rpy.tests</module>
+	</modules>
+</project>
\ No newline at end of file
