1.1 --- a/mdr/test/cfg-unit.xml Thu Aug 29 15:26:41 2002 +0000
1.2 +++ b/mdr/test/cfg-unit.xml Mon Sep 02 12:53:58 2002 +0000
1.3 @@ -28,6 +28,7 @@
1.4 <testset dir="unit/src">
1.5 <patternset>
1.6 <include name="org/netbeans/mdr/test/MDRExportImportTest.class"/>
1.7 + <include name="org/netbeans/mdr/test/AdvancedXMITest.class"/>
1.8 <include name="org/netbeans/mdr/test/PackageInheritanceTest.class"/>
1.9 <include name="org/netbeans/mdr/test/MultivaluedIndexTest.class"/>
1.10 <include name="org/netbeans/mdr/test/FederationTest.class"/>
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
2.2 +++ b/mdr/test/unit/src/org/netbeans/mdr/test/AdvancedXMITest.java Mon Sep 02 12:53:58 2002 +0000
2.3 @@ -0,0 +1,408 @@
2.4 +/*
2.5 + * Sun Public License Notice
2.6 + *
2.7 + * The contents of this file are subject to the Sun Public License
2.8 + * Version 1.0 (the "License"). You may not use this file except in
2.9 + * compliance with the License. A copy of the License is available at
2.10 + * http://www.sun.com/
2.11 + *
2.12 + * The Original Code is NetBeans. The Initial Developer of the Original
2.13 + * Code is Sun Microsystems, Inc. Portions Copyright 1997-2001 Sun
2.14 + * Microsystems, Inc. All Rights Reserved.
2.15 + */
2.16 +
2.17 +package org.netbeans.mdr.test;
2.18 +
2.19 +import java.io.*;
2.20 +import java.util.*;
2.21 +import java.net.*;
2.22 +
2.23 +import junit.extensions.*;
2.24 +
2.25 +import org.netbeans.api.xmi.*;
2.26 +import org.netbeans.api.xmi.sax.*;
2.27 +import org.openide.util.Lookup;
2.28 +import org.netbeans.junit.*;
2.29 +
2.30 +import org.netbeans.mdr.util.*;
2.31 +import org.netbeans.mdr.NBMDRepositoryImpl;
2.32 +import org.netbeans.lib.jmi.xmi.*;
2.33 +import org.netbeans.lib.jmi.mapping.*;
2.34 +
2.35 +import org.xml.sax.*;
2.36 +
2.37 +import javax.jmi.reflect.*;
2.38 +import javax.jmi.model.*;
2.39 +
2.40 +import text.*;
2.41 +
2.42 +/**
2.43 + * Test case verifying functionality of XmiReader and XmiWriter.
2.44 + */
2.45 +public class AdvancedXMITest extends MDRTestCase {
2.46 +
2.47 + public static final int N = 3;
2.48 + public static String [] name = new String [N];
2.49 + public static File [] file = new File [N];
2.50 +
2.51 + static {
2.52 + name [0] = "temp.xml";
2.53 + name [1] = "extFile_A.xml";
2.54 + name [2] = "extFile_B.xml";
2.55 +
2.56 + for (int x = 0; x < N; x++) {
2.57 + file [x] = new File (name [x]);
2.58 + }
2.59 + }
2.60 +
2.61 + public AdvancedXMITest(String testName) {
2.62 + super (testName);
2.63 + }
2.64 +
2.65 + public static void main (String[] args) {
2.66 + junit.textui.TestRunner.run (suite ());
2.67 + }
2.68 +
2.69 + public static NbTest suite () {
2.70 + NbTestSuite suite = new NbTestSuite ();
2.71 + suite.addTestSuite (AdvancedXMITest.class);
2.72 +
2.73 + NbTestSetup setup = new NbTestSetup (suite) {
2.74 + public void setUp () {
2.75 + }
2.76 + public void tearDown () {
2.77 + }
2.78 + };
2.79 + return setup;
2.80 + }
2.81 +
2.82 + /*
2.83 + public void testUML () {
2.84 + // load UML metamodel
2.85 + ModelPackage model = loadMOFModel("01-02-15_Diff.xml", "model");
2.86 + // instantiate UML metamodels
2.87 + RefPackage pkg = createExtent (findMofPackage(model, "UML"), "UML");
2.88 + RefPackage pkg_2 = createExtent (findMofPackage(model, "UML"), "UML");
2.89 + // generate random instances and links
2.90 + new RandomDataGenerator ().generate (pkg, 0, 12);
2.91 +
2.92 + Lookup lookup = Lookup.getDefault ();
2.93 +
2.94 + XMIWriter writer = XMIWriterFactory.getDefault ().createXMIWriter ();
2.95 + XMIReader reader = XMIReaderFactory.getDefault ().createXMIReader ();
2.96 + writer.getConfiguration().setReferenceProvider(new Provider ());
2.97 +
2.98 + for (int x = 0; x < N; x++) {
2.99 + try {
2.100 + OutputStream os = new FileOutputStream (file [x]);
2.101 + repository.beginTrans (true);
2.102 + writer.write (os, name [x], pkg, null);
2.103 + os.flush ();
2.104 + os.close ();
2.105 + } catch (Exception e) {
2.106 + e.printStackTrace();
2.107 + fail (e.getMessage ());
2.108 + } finally {
2.109 + repository.endTrans ();
2.110 + }
2.111 + }
2.112 +
2.113 + try {
2.114 + repository.beginTrans (true);
2.115 + reader.read (file[0].toURL ().toExternalForm (), pkg_2);
2.116 + } catch (Exception e) {
2.117 + fail (e.getMessage ());
2.118 + } finally {
2.119 + repository.endTrans ();
2.120 + }
2.121 +
2.122 + compareData (pkg, pkg_2, new HashSet ());
2.123 +
2.124 + }
2.125 + */
2.126 +
2.127 + // **************************************************************************
2.128 +
2.129 + public void testConsumerProducer () {
2.130 + RefPackage pkg = instantiateModel ("Java.xml", "Core");
2.131 + new RandomDataGenerator ().generate (pkg, 122, 8);
2.132 + RefPackage pkg_2 = instantiateModel ("Java.xml", "Core");
2.133 +
2.134 + Lookup lookup = Lookup.getDefault ();
2.135 +
2.136 + XMIProducer producer = XMIProducerFactory.getDefault ().createXMIProducer ();
2.137 + XMIConsumer consumer = XMIConsumerFactory.getDefault ().createXMIConsumer ();
2.138 +
2.139 + producer.setSource (pkg);
2.140 + producer.setContentHandler (consumer);
2.141 + consumer.setExtent (pkg_2);
2.142 +
2.143 + try {
2.144 + producer.parse ((String) null);
2.145 + } catch (Exception e) {
2.146 + fail (e.getMessage ());
2.147 + }
2.148 +
2.149 + compareData (pkg, pkg_2, new HashSet ());
2.150 +
2.151 + }
2.152 +
2.153 + // **************************************************************************
2.154 +
2.155 + public void testReferenceProvider () {
2.156 + RefPackage pkg = instantiateModel ("Java.xml", "Core");
2.157 + new RandomDataGenerator ().generate (pkg, 0, 7);
2.158 +
2.159 + Lookup lookup = Lookup.getDefault ();
2.160 +
2.161 + XMIWriter writer = XMIWriterFactory.getDefault ().createXMIWriter ();
2.162 + XMIReader reader = XMIReaderFactory.getDefault ().createXMIReader ();
2.163 + writer.getConfiguration().setReferenceProvider(new Provider ());
2.164 +
2.165 + for (int x = 0; x < N; x++) {
2.166 + try {
2.167 + OutputStream os = new FileOutputStream (file [x]);
2.168 + repository.beginTrans (true);
2.169 + writer.write (os, name [x], pkg, null);
2.170 + os.flush ();
2.171 + os.close ();
2.172 + } catch (Exception e) {
2.173 + e.printStackTrace();
2.174 + fail (e.getMessage ());
2.175 + } finally {
2.176 + repository.endTrans ();
2.177 + }
2.178 + }
2.179 +
2.180 + RefPackage pkg_2 = instantiateModel ("Java.xml", "Core");
2.181 + try {
2.182 + repository.beginTrans (true);
2.183 + reader.read (file[0].toURL ().toExternalForm (), pkg_2);
2.184 + } catch (Exception e) {
2.185 + fail (e.getMessage ());
2.186 + } finally {
2.187 + repository.endTrans ();
2.188 + }
2.189 +
2.190 + compareData (pkg, pkg_2, new HashSet ());
2.191 +
2.192 + }
2.193 +
2.194 + // **************************************************************************
2.195 +
2.196 + public void testReferenceResolver () {
2.197 + RefPackage pkg = instantiateModel ("Text.xml", "Text");
2.198 + new RandomDataGenerator ().generate (pkg, 0, 3);
2.199 +
2.200 + Lookup lookup = Lookup.getDefault ();
2.201 +
2.202 + XMIWriter writer = XMIWriterFactory.getDefault ().createXMIWriter ();
2.203 + XMIReader reader = XMIReaderFactory.getDefault ().createXMIReader ();
2.204 + writer.getConfiguration().setReferenceProvider(new TextProvider ());
2.205 + reader.getConfiguration().setReferenceResolver(new TextResolver ());
2.206 +
2.207 + try {
2.208 + OutputStream os = new FileOutputStream ("textExp.xml");
2.209 + repository.beginTrans (true);
2.210 + writer.write (os, "textExp.xml", pkg, null);
2.211 + os.flush ();
2.212 + os.close ();
2.213 + } catch (Exception e) {
2.214 + e.printStackTrace();
2.215 + fail (e.getMessage ());
2.216 + } finally {
2.217 + repository.endTrans ();
2.218 + }
2.219 +
2.220 + try {
2.221 + OutputStream os = new FileOutputStream ("words.xml");
2.222 + repository.beginTrans (true);
2.223 + writer.write (os, "words.xml", pkg, null);
2.224 + os.flush ();
2.225 + os.close ();
2.226 + } catch (Exception e) {
2.227 + e.printStackTrace();
2.228 + fail (e.getMessage ());
2.229 + } finally {
2.230 + repository.endTrans ();
2.231 + }
2.232 +
2.233 + File file = new File ("textExp.xml");
2.234 + RefPackage pkg_2 = instantiateModel ("Text.xml", "Text");
2.235 + try {
2.236 + repository.beginTrans (true);
2.237 + reader.read (file.toURL ().toExternalForm (), pkg_2);
2.238 + } catch (Exception e) {
2.239 + fail (e.getMessage ());
2.240 + } finally {
2.241 + repository.endTrans ();
2.242 + }
2.243 +
2.244 + // compareData (pkg, pkg_2, new HashSet ());
2.245 +
2.246 + }
2.247 +
2.248 + // **************************************************************************
2.249 +
2.250 + public void testHeaderProvider () {
2.251 + RefPackage pkg = instantiateModel ("Java.xml", "Core");
2.252 + new RandomDataGenerator ().generate (pkg, 0, 3);
2.253 +
2.254 + Lookup lookup = Lookup.getDefault ();
2.255 +
2.256 + XMIWriter writer = XMIWriterFactory.getDefault ().createXMIWriter ();
2.257 + XMIReader reader = XMIReaderFactory.getDefault ().createXMIReader ();
2.258 + ((OutputConfig)writer.getConfiguration()).setHeaderProvider(new HeaderProvider ());
2.259 + ((InputConfig)reader.getConfiguration()).setHeaderConsumer(new HeaderConsumer ());
2.260 +
2.261 + try {
2.262 + OutputStream os = new FileOutputStream ("headerTest.xml");
2.263 + repository.beginTrans (true);
2.264 + writer.write (os, null, pkg, null);
2.265 + os.flush ();
2.266 + os.close ();
2.267 + } catch (Exception e) {
2.268 + e.printStackTrace();
2.269 + fail (e.getMessage ());
2.270 + } finally {
2.271 + repository.endTrans ();
2.272 + }
2.273 +
2.274 + File file = new File ("headerTest.xml");
2.275 + RefPackage pkg_2 = instantiateModel ("Java.xml", "Core");
2.276 + try {
2.277 + repository.beginTrans (true);
2.278 + reader.read (file.toURL ().toExternalForm (), pkg_2);
2.279 + } catch (Exception e) {
2.280 + fail (e.getMessage ());
2.281 + } finally {
2.282 + repository.endTrans ();
2.283 + }
2.284 +
2.285 + compareData (pkg, pkg_2, new HashSet ());
2.286 +
2.287 + }
2.288 +
2.289 + // **************************************************************************
2.290 +
2.291 + /**
2.292 + * Creates extent for a metamodel specified by an XMI document.
2.293 + *
2.294 + * @param docName XMI document name
2.295 + * @param mainPackageName name of a MofPackage (included in XMI document) to instantiate
2.296 + *
2.297 + * @return created extent
2.298 + */
2.299 + private RefPackage instantiateModel (String docName, String mainPackageName) {
2.300 + ModelPackage pkg = loadMOFModel (docName, "PureMOF_test");
2.301 + RefPackage result = createExtent (
2.302 + findMofPackage (pkg, mainPackageName),
2.303 + mainPackageName
2.304 + );
2.305 + return result;
2.306 + }
2.307 +
2.308 + /**
2.309 + * Compares instances counts in packages, fails if there is a proxy with different number
2.310 + * of instantiated objects in each package.
2.311 + */
2.312 + private void compareData (RefPackage pkg_1, RefPackage pkg_2, Set checkedPackages) {
2.313 + Set set = new HashSet ();
2.314 + checkedPackages.add (pkg_1);
2.315 + Iterator iter = pkg_1.refAllClasses ().iterator ();
2.316 + while (iter.hasNext ()) {
2.317 + RefClass proxy = (RefClass) iter.next ();
2.318 + ModelElement meta = (ModelElement) proxy.refMetaObject ();
2.319 + int count = proxy.refAllOfClass ().size ();
2.320 + int count2 = pkg_2.refClass (meta).refAllOfClass ().size ();
2.321 + if (count != count2)
2.322 + fail ("Number of instances does not match: " + meta.getName () + " " + count + " " + count2);
2.323 + }
2.324 + iter = pkg_1.refAllAssociations ().iterator ();
2.325 + while (iter.hasNext ()) {
2.326 + RefAssociation proxy = (RefAssociation) iter.next ();
2.327 + ModelElement meta = (ModelElement) proxy.refMetaObject ();
2.328 + int count = proxy.refAllLinks ().size ();
2.329 + int count2 = pkg_2.refAssociation (meta).refAllLinks ().size ();
2.330 + if (count != count2)
2.331 + fail ("Number of links does not match: " + meta.getName () + " " + count + " " + count2);
2.332 + }
2.333 + iter = pkg_1.refAllPackages ().iterator ();
2.334 + while (iter.hasNext ()) {
2.335 + RefPackage p1 = (RefPackage) iter.next ();
2.336 + ModelElement meta = (ModelElement) p1.refMetaObject ();
2.337 + RefPackage p2 = pkg_2.refPackage (meta);
2.338 + compareData (p1, p2, checkedPackages);
2.339 + }
2.340 + }
2.341 +
2.342 + // Providers & Resolvers ....................................................
2.343 +
2.344 + public static class Provider implements XMIReferenceProvider {
2.345 +
2.346 + public XMIReferenceProvider.XMIReference getReference (RefObject obj) {
2.347 + return new XMIReferenceProvider.XMIReference (name [obj.hashCode () % N], obj.refMofId ());
2.348 + }
2.349 +
2.350 + }
2.351 +
2.352 + public static class TextProvider implements XMIReferenceProvider {
2.353 +
2.354 + public XMIReferenceProvider.XMIReference getReference (RefObject obj) {
2.355 + String systemId;
2.356 + String xmiId = obj.refMofId ();
2.357 + if (((MofClass)obj.refMetaObject ()).getName ().equals ("Word"))
2.358 + systemId = "words.xml";
2.359 + else
2.360 + systemId = "textExp.xml";
2.361 + return new XMIReferenceProvider.XMIReference (systemId, xmiId);
2.362 + }
2.363 +
2.364 + }
2.365 +
2.366 + public static class TextResolver implements XMIReferenceResolver {
2.367 +
2.368 + public void register(String systemId, String xmiId, RefObject object) {
2.369 + }
2.370 +
2.371 + public void resolve(Client client, RefPackage extent, String systemId, XMIInputConfig configuration, Collection hrefs) {
2.372 + Iterator iter = hrefs.iterator ();
2.373 + while (iter.hasNext ()) {
2.374 + String href = (String) iter.next ();
2.375 + WordClass proxy = ((TextPackage) extent).getWord ();
2.376 + client.resolvedReference (href, proxy.createWord ());
2.377 + } // while
2.378 + }
2.379 +
2.380 + }
2.381 +
2.382 + // Header provider & consumer ...............................................
2.383 +
2.384 + public static class HeaderProvider implements XMIHeaderProvider {
2.385 +
2.386 + public void writeHeader (PrintStream stream) {
2.387 + stream.println("<XMI.documentation>");
2.388 + stream.println(" <XMI.exporter>Netbeans XMI Writer</XMI.exporter>");
2.389 + stream.println(" <XMI.exporterVersion>1.0</XMI.exporterVersion>");
2.390 + stream.println("</XMI.documentation>");
2.391 + }
2.392 +
2.393 + }
2.394 +
2.395 + public static class HeaderConsumer implements XMIHeaderConsumer {
2.396 +
2.397 + public void consumeHeader (InputStream stream) {
2.398 + System.out.println("HEADER:");
2.399 + try {
2.400 + int b = stream.read ();
2.401 + while (b != -1) {
2.402 + System.out.print("" + ((char)b));
2.403 + b = stream.read ();
2.404 + }
2.405 + } catch (IOException e) {
2.406 + }
2.407 + }
2.408 +
2.409 + }
2.410 +
2.411 +}
3.1 --- a/mdr/test/unit/src/org/netbeans/mdr/test/MDRExportImportTest.java Thu Aug 29 15:26:41 2002 +0000
3.2 +++ b/mdr/test/unit/src/org/netbeans/mdr/test/MDRExportImportTest.java Mon Sep 02 12:53:58 2002 +0000
3.3 @@ -249,7 +249,7 @@
3.4 int count = proxy.refAllOfType ().size ();
3.5 int count2 = pkg_2.refClass (meta).refAllOfType ().size ();
3.6 if (count != count2)
3.7 - fail ("Number of instances does not match: " + meta.getName ());
3.8 + fail ("Number of instances does not match: " + meta.getName () + " " + count + " " + count2);
3.9 }
3.10 iter = pkg_1.refAllAssociations ().iterator ();
3.11 while (iter.hasNext ()) {
3.12 @@ -258,7 +258,7 @@
3.13 int count = proxy.refAllLinks ().size ();
3.14 int count2 = pkg_2.refAssociation (meta).refAllLinks ().size ();
3.15 if (count != count2)
3.16 - fail ("Number of links does not match: " + meta.getName ());
3.17 + fail ("Number of links does not match: " + meta.getName () + " " + count + " " + count2);
3.18 }
3.19 iter = pkg_1.refAllPackages ().iterator ();
3.20 while (iter.hasNext ()) {
3.21 @@ -302,6 +302,7 @@
3.22 os.flush ();
3.23 os.close ();
3.24 } catch (Exception e) {
3.25 + e.printStackTrace ();
3.26 fail (e.getMessage ());
3.27 } finally {
3.28 repository.endTrans ();
4.1 --- a/mdr/test/unit/src/org/netbeans/mdr/test/RandomDataGenerator.java Thu Aug 29 15:26:41 2002 +0000
4.2 +++ b/mdr/test/unit/src/org/netbeans/mdr/test/RandomDataGenerator.java Mon Sep 02 12:53:58 2002 +0000
4.3 @@ -203,6 +203,10 @@
4.4 // we limit the nuber of generated values to be between 1 and 10
4.5 if (count == 0) count = 1;
4.6 if (count > 10) count = 10;
4.7 +
4.8 + if (multType.isUnique ())
4.9 + count = 1;
4.10 +
4.11 List values = new LinkedList ();
4.12 for (int x = 0; x < count; x++)
4.13 values.add (generateValue (type));