ontomde-java 2.0.0

data/test/src/RuntimeTest.java

@@ -0,0 +1,656 @@
+//package junit.samples;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Set;
+
+import org.junit.Assert;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import pack1.ClasseDeTest;
+import pack1.Couleurs;
+import pack1.InterfaceComposante;
+import pack1.assignable.Interface5Assignable;
+import pack1.pack11.ClassDeuxNxPkg;
+import pack2.ClassA;
+import pack2.Classe3;
+import pack2.CompositeTargetClas;
+import pack2.assignable.CompositeTargetClasAssignable;
+
+/**
+ * Some simple tests.
+ * 
+ */
+public class RuntimeTest extends TestCase {
+	final int testLevel = 1;
+
+	public void testEcho() {
+	}
+
+	public void testGetSetInt() {
+		final int i1 = 45, i2 = 33;
+		pack1.ClasseDeTest cdt = new pack1.ClasseDeTest();
+
+		assertEquals(cdt.getAnIntAttribute(), 0);
+
+		cdt.setAnIntAttribute(i1);
+		assertEquals(cdt.getAnIntAttribute(), i1);
+		cdt.setAnIntAttribute(i2);
+		assertEquals(cdt.getAnIntAttribute(), i2);
+
+		cdt.setAnIntAttribute(0);
+		assertEquals(cdt.getAnIntAttribute(), 0);
+	}
+
+	public void testGetSetString() {
+		final String s1 = "abcd", s2 = "efth";
+		pack1.ClasseDeTest cdt = new pack1.ClasseDeTest();
+
+		assertNull(cdt.getaStringAttribute());
+
+		cdt.setaStringAttribute(s1);
+		assertEquals(cdt.getaStringAttribute(), s1);
+
+		cdt.setaStringAttribute(s2);
+		assertEquals(cdt.getaStringAttribute(), s2);
+
+		cdt.setaStringAttribute(null);
+		assertNull(cdt.getaStringAttribute());
+	}
+
+	public void testGetSetStringArrayIsSafe() {
+		final String s1 = "abcd", s2 = "efth";
+		pack1.ClasseDeTest cdt = new pack1.ClasseDeTest();
+		cdt.addaStringArrayAttribute(s1);
+		Set<String> set1 = cdt.getaStringArrayAttribute();
+		set1.add(s2);
+		if (testLevel > 1) {
+			assertFalse(cdt.getaStringAttribute().contains(s2));
+		}
+	}
+
+	public void testGetSetStringGlobal() {
+		final String s1 = "abcd", s2 = "efth", s3 = "ijkl";
+		Set<String> set1 = new HashSet<String>();
+		Set<String> set2 = new HashSet<String>();
+		Set<String> set3 = new HashSet<String>();
+
+		set1.add(s1);
+		set1.add(s2);
+		set2.add(s2);
+		set2.add(s3);
+		set3.add(s3);
+		set3.add(s1);
+
+		pack1.ClasseDeTest cdt = new pack1.ClasseDeTest();
+
+		cdt.setaStringArrayAttribute(set1);
+		assertTrue(cdt.getaStringArrayAttribute().contains(s1));
+		assertTrue(cdt.getaStringArrayAttribute().contains(s2));
+		assertFalse(cdt.getaStringArrayAttribute().contains(s3));
+
+		cdt.setaStringArrayAttribute(set2);
+		assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+		assertTrue(cdt.getaStringArrayAttribute().contains(s2));
+		assertTrue(cdt.getaStringArrayAttribute().contains(s3));
+
+		cdt.setaStringArrayAttribute(set3);
+		assertTrue(cdt.getaStringArrayAttribute().contains(s1));
+		assertFalse(cdt.getaStringArrayAttribute().contains(s2));
+		assertTrue(cdt.getaStringArrayAttribute().contains(s3));
+
+		cdt.setaStringArrayAttribute(null);
+		if (true) { // TODO: decide which is right
+			assertNotNull(cdt.getaStringArrayAttribute());
+			assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+			assertFalse(cdt.getaStringArrayAttribute().contains(s2));
+			assertFalse(cdt.getaStringArrayAttribute().contains(s3));
+		} else {
+			assertNull(cdt.getaStringArrayAttribute());
+		}
+
+	}
+
+	public void testGetSetStringArrayAppendRemove() {
+		final String s1 = "abcd", s2 = "efth", s3 = "ijkl";
+		pack1.ClasseDeTest cdt = new pack1.ClasseDeTest();
+
+		assertNotNull(cdt.getaStringArrayAttribute());
+		assertTrue(cdt.getaStringArrayAttribute().isEmpty());
+
+		// add remove on empty array
+		assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+		cdt.addaStringArrayAttribute(s1);
+		assertTrue(cdt.getaStringArrayAttribute().contains(s1));
+		cdt.removeaStringArrayAttribute(s1);
+		assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+
+		assertFalse(cdt.getaStringArrayAttribute().contains(s2));
+		cdt.addaStringArrayAttribute(s2);
+		assertTrue(cdt.getaStringArrayAttribute().contains(s2));
+		// add remove on non empty array
+		assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+		assertTrue(cdt.getaStringArrayAttribute().contains(s2));
+		cdt.addaStringArrayAttribute(s1);
+		cdt.addaStringArrayAttribute(s3);
+		cdt.removeaStringArrayAttribute(s2);
+		assertTrue(cdt.getaStringArrayAttribute().contains(s1));
+		cdt.removeaStringArrayAttribute(s1);
+		assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+
+		assertFalse(cdt.getaStringArrayAttribute().contains(s1));
+		assertFalse(cdt.getaStringArrayAttribute().contains(s2));
+
+		cdt.addaStringArrayAttribute(s2);
+	}
+
+	public void testEnumeratedAttribute() {
+		ClasseDeTest cdt = new ClasseDeTest();
+		assertNull(cdt.getCouleur());
+		cdt.setCouleur(Couleurs.Carreau);
+		assertTrue(cdt.getCouleur() == Couleurs.Carreau);
+		cdt.setCouleur(Couleurs.Pique);
+		assertTrue(cdt.getCouleur() == Couleurs.Pique);
+		cdt.setCouleur(null);
+		assertNull(cdt.getCouleur());
+	}
+
+	public void testBidiOneToOne() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		ClassDeuxNxPkg cdnx1 = new ClassDeuxNxPkg();
+		ClassDeuxNxPkg cdnx2 = new ClassDeuxNxPkg();
+
+		assertNull(cdt1.getBidi_c2_1_1());
+
+		cdt1.setBidi_c2_1_1(cdnx1);
+		assertEquals(cdt1.getBidi_c2_1_1(), cdnx1);
+		assertEquals(cdnx1.getBidi_cdt_1_1(), cdt1);
+
+		cdt1.setBidi_c2_1_1(cdnx2);
+		assertEquals(cdt1.getBidi_c2_1_1(), cdnx2);
+		assertEquals(cdnx2.getBidi_cdt_1_1(), cdt1);
+		assertNull(cdnx1.getBidi_cdt_1_1());
+
+		cdt1.setBidi_c2_1_1(null);
+		assertNull(cdt1.getBidi_c2_1_1());
+		assertNull(cdnx1.getBidi_cdt_1_1());
+		assertNull(cdnx2.getBidi_cdt_1_1());
+	}
+
+	public void testBidiManyToOneAppendRemove() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		ClasseDeTest cdt2 = new ClasseDeTest();
+		ClassDeuxNxPkg cdnx1 = new ClassDeuxNxPkg();
+		ClassDeuxNxPkg cdnx2 = new ClassDeuxNxPkg();
+
+		cdt1.addBidi_c2_2_s(cdnx1);
+		cdt1.addBidi_c2_2_s(cdnx2);
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx1));
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx2));
+		assertEquals(cdt1, cdnx1.getBidi_cdt_2_1());
+		assertEquals(cdt1, cdnx2.getBidi_cdt_2_1());
+
+		cdt1.removeBidi_c2_2_s(cdnx1);
+		assertNull(cdnx1.getBidi_cdt_2_1());
+		assertEquals(cdt1, cdnx2.getBidi_cdt_2_1());
+		assertFalse(cdt1.getBidi_c2_2_s().contains(cdnx1));
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx2));
+
+		cdnx2.setBidi_cdt_2_1(cdt2);
+		assertFalse(cdt1.getBidi_c2_2_s().contains(cdnx2));
+		assertTrue(cdt2.getBidi_c2_2_s().contains(cdnx2));
+		assertEquals(cdnx2.getBidi_cdt_2_1(), cdt2);
+	}
+
+	public void testBidiManyToOneGlobal() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		ClassDeuxNxPkg cdnx1 = new ClassDeuxNxPkg();
+		ClassDeuxNxPkg cdnx2 = new ClassDeuxNxPkg();
+		ClassDeuxNxPkg cdnx3 = new ClassDeuxNxPkg();
+		Set<ClassDeuxNxPkg> scdnx1 = new HashSet<ClassDeuxNxPkg>();
+		Set<ClassDeuxNxPkg> scdnx2 = new HashSet<ClassDeuxNxPkg>();
+
+		scdnx1.add(cdnx1);
+		scdnx1.add(cdnx2);
+		scdnx2.add(cdnx2);
+		scdnx2.add(cdnx3);
+
+		// simultaneous appends
+		cdt1.setBidi_c2_2_s(scdnx1);
+		assertEquals(cdnx1.getBidi_cdt_2_1(), cdt1);
+		assertEquals(cdnx2.getBidi_cdt_2_1(), cdt1);
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx1));
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx2));
+
+		// simultaneous append and remove
+		cdt1.setBidi_c2_2_s(scdnx2);
+		assertNull(cdnx1.getBidi_cdt_2_1());
+		assertEquals(cdnx2.getBidi_cdt_2_1(), cdt1);
+		assertEquals(cdnx3.getBidi_cdt_2_1(), cdt1);
+		assertFalse(cdt1.getBidi_c2_2_s().contains(cdnx1));
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx2));
+		assertTrue(cdt1.getBidi_c2_2_s().contains(cdnx3));
+	}
+
+	public void testBidiManyToManyGlobal() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		ClassDeuxNxPkg cdnx1 = new ClassDeuxNxPkg();
+		ClassDeuxNxPkg cdnx2 = new ClassDeuxNxPkg();
+		ClassDeuxNxPkg cdnx3 = new ClassDeuxNxPkg();
+		Set<ClassDeuxNxPkg> scdnx1 = new HashSet<ClassDeuxNxPkg>();
+		Set<ClassDeuxNxPkg> scdnx2 = new HashSet<ClassDeuxNxPkg>();
+
+		scdnx1.add(cdnx1);
+		scdnx1.add(cdnx2);
+		scdnx2.add(cdnx2);
+		scdnx2.add(cdnx3);
+
+		// simultaneous appends
+		cdt1.setBidi_c2_3_s(scdnx1);
+		assertTrue(cdnx1.getBidi_cdt_3_s().contains(cdt1));
+		assertTrue(cdnx2.getBidi_cdt_3_s().contains(cdt1));
+		assertTrue(cdt1.getBidi_c2_3_s().contains(cdnx1));
+		assertTrue(cdt1.getBidi_c2_3_s().contains(cdnx2));
+
+		// simultaneous append and remove
+		cdt1.setBidi_c2_3_s(scdnx2);
+		assertFalse(cdnx1.getBidi_cdt_3_s().contains(cdt1));
+		assertTrue(cdnx2.getBidi_cdt_3_s().contains(cdt1));
+		assertTrue(cdnx3.getBidi_cdt_3_s().contains(cdt1));
+		assertFalse(cdt1.getBidi_c2_3_s().contains(cdnx1));
+		assertTrue(cdt1.getBidi_c2_3_s().contains(cdnx2));
+		assertTrue(cdt1.getBidi_c2_3_s().contains(cdnx3));
+	}
+
+	public void testQualifierManyToOneMonoOrientedGlobal() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		Classe3 ct1 = new Classe3();
+		Classe3 ct2 = new Classe3();
+		Classe3 ct3 = new Classe3();
+		Hashtable<String, Classe3> hct1 = new Hashtable<String, Classe3>();
+		Hashtable<String, Classe3> hct2 = new Hashtable<String, Classe3>();
+		String s1 = "abcd", s2 = "efgh", s3 = "ijkl";
+
+		hct1.put(s1, ct1);
+		hct1.put(s2, ct2);
+		hct2.put(s2, ct2);
+		hct2.put(s3, ct3);
+
+		cdt1.setWithQualifier(hct1);
+		assertEquals(cdt1.getWithQualifier().get(s1), ct1);
+		assertEquals(cdt1.getWithQualifier().get(s2), ct2);
+
+		cdt1.setWithQualifier(hct2);
+		assertNull(cdt1.getWithQualifier().get(s1));
+		assertEquals(cdt1.getWithQualifier().get(s2), ct2);
+		assertEquals(cdt1.getWithQualifier().get(s3), ct3);
+	}
+
+	public void testQualifierManyToOneMonoOriented() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+
+		Classe3 ct1 = new Classe3();
+		Classe3 ct2 = new Classe3();
+
+		String s1 = "abcd", s2 = "efgh", s3 = "ijkl";
+
+		cdt1.putWithQualifier(s1, ct1);
+		assertEquals(cdt1.getWithQualifier(s1), ct1);
+
+		cdt1.putWithQualifier(s2, ct2);
+		assertEquals(cdt1.getWithQualifier(s1), ct1);
+		assertEquals(cdt1.getWithQualifier(s2), ct2);
+
+		cdt1.putWithQualifier(s2, ct1);
+		assertEquals(cdt1.getWithQualifier(s1), ct1);
+		assertEquals(cdt1.getWithQualifier(s2), ct1);
+
+		cdt1.putWithQualifier(s2, null);
+		assertNull(cdt1.getWithQualifier(s2));
+		assertEquals(cdt1.getWithQualifier(s1), ct1);
+
+		cdt1.putWithQualifier(s3, null);
+	}
+
+	@SuppressWarnings("unused")
+	public void testQualifierToManyMono() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+
+		Classe3 ct1 = new Classe3();
+		Classe3 ct2 = new Classe3();
+		Hashtable<String, Set<Classe3>> hs1 = new Hashtable<String, Set<Classe3>>();
+
+		String s1 = "abcd", s2 = "efgh", s3 = "ijkl";
+		// TODO! assertNotNull(cdt1.getWithQualifierMany());
+	}
+
+	public void testQualifierManyToOneBidi() {
+		if (testLevel <= 1) {
+			return;
+		}
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		Classe3 ct1 = new Classe3();
+		Classe3 ct2 = new Classe3();
+		Classe3 ct3 = new Classe3();
+		Hashtable<String, Classe3> hct1 = new Hashtable<String, Classe3>();
+		Hashtable<String, Classe3> hct2 = new Hashtable<String, Classe3>();
+		String s1 = "abcd", s2 = "efgh", s3 = "ijkl";
+
+		hct1.put(s1, ct1);
+		hct1.put(s2, ct2);
+		hct2.put(s2, ct2);
+		hct2.put(s3, ct3);
+
+		cdt1.setWithQualifierBiNav(hct1);
+		assertEquals(cdt1.getWithQualifierBiNav().get(s1), ct1);
+		assertEquals(cdt1.getWithQualifierBiNav().get(s2), ct2);
+		assertEquals(ct1.getInvQual(), cdt1);
+		assertEquals(ct2.getInvQual(), cdt1);
+
+		cdt1.setWithQualifierBiNav(hct2);
+		assertNull(cdt1.getWithQualifierBiNav().get(s1));
+		assertEquals(cdt1.getWithQualifierBiNav().get(s2), ct2);
+		assertEquals(cdt1.getWithQualifierBiNav().get(s3), ct3);
+		assertNull(ct1.getInvQual());
+		assertEquals(ct2.getInvQual(), cdt1);
+		assertEquals(ct3.getInvQual(), cdt1);
+	}
+
+	public void testCompositeCreator() {
+
+	}
+
+	public void testSortedClassA() {
+		ClasseDeTest cdt = new ClasseDeTest();
+		ClassA ct1 = new ClassA();
+		ClassA ct2 = new ClassA();
+		ClassA ct3 = new ClassA();
+		List<pack2.ClassA> lct1 = new ArrayList<pack2.ClassA>();
+		List<pack2.ClassA> lct2 = new ArrayList<pack2.ClassA>();
+
+		lct1.add(ct1);
+		lct1.add(ct2);
+		lct2.add(ct2);
+		lct2.add(ct3);
+
+		cdt.setSortedA(lct1);
+		assertEquals(cdt.getSortedA().get(0), ct1);
+		assertEquals(cdt.getSortedA().get(1), ct2);
+		assertTrue(cdt.getSortedA().contains(ct1));
+		assertTrue(cdt.getSortedA().contains(ct2));
+		cdt.removeSortedA(ct1);
+		assertFalse(cdt.getSortedA().contains(ct1));
+		cdt.addSortedA(ct3);
+		assertTrue(cdt.getSortedA().contains(ct3));
+		cdt.addSortedA(0, ct2);
+		assertEquals(cdt.getSortedA().get(0), ct2);
+
+		cdt.setSortedA(lct2);
+		assertEquals(cdt.getSortedA().get(0), ct2);
+		assertEquals(cdt.getSortedA().get(1), ct3);
+		assertTrue(cdt.getSortedA().contains(ct2));
+		assertFalse(cdt.getSortedA().contains(ct1));
+		cdt.removeSortedA(ct2);
+		assertFalse(cdt.getSortedA().contains(ct2));
+		cdt.addSortedA(ct1);
+		assertTrue(cdt.getSortedA().contains(ct1));
+		cdt.addSortedA(0, ct3);
+		assertTrue(cdt.getSortedA().get(0).equals(ct3));
+	}
+
+	public void testGetReadOnly() {
+		ClasseDeTest cdt = new ClasseDeTest();
+		ClassA ct1 = new ClassA();
+		ClassA ct2 = new ClassA();
+		// ClassA ct3 = new ClassA();
+
+		ct1 = cdt.getReadOnlyT();
+		assertEquals(cdt.getReadOnlyT(), ct1);
+		ct2 = cdt.getReadOnlyT();
+		assertEquals(cdt.getReadOnlyT(), ct2);
+	}
+
+	
+	
+	public void testAssignableInterface5(){
+		boolean found=false;
+		for (int i = 0; i < Interface5Assignable.values().length; i++) {
+			//Interface5Assignable.values()[i];
+			if((Interface5Assignable.values()[i].name().compareTo("pack1_dot_ClasseDeTest")==0)) {
+				found=true;
+			}
+		}
+		assertTrue("ClasseDeTest should be Assignable for Interface5",found);
+	}
+	
+	
+	public void testCreateAndAddMany() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		CompositeTargetClas ctc1;
+		CompositeTargetClas ctc2 = new CompositeTargetClas();
+		// CompositeTargetClas ctc3 ;
+		
+		CompositeTargetClasAssignable t=null;
+		t=CompositeTargetClasAssignable.pack2_dot_CompositeTargetClas;
+		
+		ctc1 = cdt1.createAndAddCompositeElement(t);
+		assertNotNull(ctc1);
+		assertTrue(cdt1.getCompositeElement().contains(ctc1));
+		assertFalse(cdt1.getCompositeElement().contains(ctc2));
+	}
+	
+	@SuppressWarnings("unused")
+	public void testCreateAndAddOne() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		CompositeTargetClas ctc1;
+		CompositeTargetClas ctc2 = new CompositeTargetClas();
+		// CompositeTargetClas ctc3 ;
+		
+		CompositeTargetClasAssignable t=null;
+		t=CompositeTargetClasAssignable.pack2_dot_CompositeTargetClas;
+		assertNull(cdt1.getCompositeElementOne());
+		ctc1 = cdt1.createAndAddCompositeElementOne(t);
+		assertNotNull(ctc1);
+		assertTrue(cdt1.getCompositeElementOne()==ctc1);
+	}
+	
+	public void testCreateAndAddNullTypeMany() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		CompositeTargetClas ctc1;
+		CompositeTargetClasAssignable t=null;
+		ctc1 = cdt1.createAndAddCompositeElement(t);
+		assertNull(ctc1);
+	}
+	
+	public void testCreateAndAddNullTypeOne() {
+		ClasseDeTest cdt1 = new ClasseDeTest();
+		CompositeTargetClas ctc1;
+		CompositeTargetClasAssignable t=null;
+		ctc1 = cdt1.createAndAddCompositeElementOne(t);
+		assertNull(ctc1);
+		assertNull(cdt1.getCompositeElementOne());
+	}
+    public void testCreateAndAddSuggesterOneOrZero() {
+    	ClasseDeTest cdt1 = new ClasseDeTest();
+    	List<CompositeTargetClasAssignable> t=cdt1.getCreateAndAddCompositeElementOneSug();
+    	assertTrue(t.contains(null));
+    	assertTrue(t.contains(CompositeTargetClasAssignable.pack2_dot_CompositeTargetClas));
+    	assertTrue(t.contains(CompositeTargetClasAssignable.pack2_dot_SubCompositeTargetClass));
+    	assertEquals(t.size(),3);
+    }
+    
+    public void testSugCouleurOneOrZero() {
+    	ClasseDeTest cdt1 = new ClasseDeTest();
+    	List<Couleurs> t=cdt1.getCouleurZeroOneSug();
+    	assertTrue(t.contains(null));
+    	assertTrue(t.contains(Couleurs.Carreau));
+    	assertEquals(t.size(),5);
+    }
+    
+    public void testSugCouleurZeroMany() {
+    	ClasseDeTest cdt1 = new ClasseDeTest();
+    	List<Couleurs> t=cdt1.getCouleurZeroManySug();
+    	assertTrue(t.contains(null));
+    	assertTrue(t.contains(Couleurs.Carreau));
+    	assertEquals(t.size(),5);
+    }
+    
+    public void testSugCouleurOneMany() {
+    	ClasseDeTest cdt1 = new ClasseDeTest();
+    	List<Couleurs> t=cdt1.getCouleurOneManySug();
+    	assertFalse(t.contains(null));
+    	assertTrue(t.contains(Couleurs.Carreau));
+    	assertEquals(t.size(),4);
+    }
+	
+	public void testObjectParameter() {
+		// Test parameter whose type is not a datatype.
+		ClasseDeTest cdt = new ClasseDeTest();
+		//Classe3 c3 = new Classe3();
+		//Set<Classe3> c3s = new HashSet<Classe3>();
+		ClassA ca=new ClassA();
+		cdt.setAnObjectParameter(ca);
+		ClassA ca2 = cdt.getAnObjectParameter();
+		ca2.getClass(); // to remove warning
+		//if (false) {
+		//	cdt.methodWithObjectParams(c3, c3s);
+		//}
+	}
+
+	public void testEmptyEnumIsEmpty() {
+		assertEquals(pack1.EmptyEnum.values().length, 0);
+	}
+
+	public void testDeriveGetNotImplemented() {
+		ClasseDeTest cdt = new ClasseDeTest();
+		try {
+			pack2.ClassA a = cdt.getDerivedA();
+			if (a == null) {
+			}
+			fail("Exception not implemented expected");
+		} catch (RuntimeException e) {
+		}
+	}
+
+	public void testDeriveSetNotImplemented() {
+		ClasseDeTest cdt = new ClasseDeTest();
+		pack2.ClassA a = null;
+		try {
+			cdt.setDerivedA(a);
+			fail("Exception not implemented expected");
+		} catch (RuntimeException e) {
+		}
+	}
+
+//	public void testEnumAsStringUsingEnum() {
+//		pack2.Car f = new pack2.Car();
+//
+//		assertNull(f.getCarCategory());
+//		assertNull(f.getCarCategoryAsString());
+//
+//		// set to null (nothing changed !)
+//		f.setCarCategory(null);
+//		assertNull(f.getCarCategory());
+//		assertNull(f.getCarCategoryAsString());
+//
+//		// set from existing null
+//		f.setCarCategory(pack2.CarCategory.Sport);
+//		assertEquals(f.getCarCategory(), pack2.CarCategory.Sport);
+//		assertEquals(f.getCarCategoryAsString(), "Sport");
+//
+//		// set from existing value
+//		f.setCarCategory(pack2.CarCategory.SUV);
+//		assertEquals(f.getCarCategory(), pack2.CarCategory.SUV);
+//		assertEquals(f.getCarCategoryAsString(), "SUV");
+//
+//		// set to null
+//		f.setCarCategory(null);
+//		assertNull(f.getCarCategory());
+//		assertNull(f.getCarCategoryAsString());
+//	}
+
+//	public void testEnumAsStringUsingString() {
+//		pack2.Car f = new pack2.Car();
+//
+//		assertNull(f.getCarCategory());
+//		assertNull(f.getCarCategoryAsString());
+//
+//		// set to null (nothing changed !)
+//		f.setCarCategoryAsString(null);
+//		assertNull(f.getCarCategory());
+//		assertNull(f.getCarCategoryAsString());
+//
+//		// set from existing null
+//		f.setCarCategoryAsString("Sport");
+//		assertEquals(f.getCarCategory(), pack2.CarCategory.Sport);
+//		assertEquals(f.getCarCategoryAsString(), "Sport");
+//
+//		// set from existing value
+//		f.setCarCategoryAsString("SUV");
+//		assertEquals(f.getCarCategory(), pack2.CarCategory.SUV);
+//		assertEquals(f.getCarCategoryAsString(), "SUV");
+//
+//		// set to null
+//		f.setCarCategoryAsString(null);
+//		assertNull(f.getCarCategory());
+//		assertNull(f.getCarCategoryAsString());
+//
+//		// set to non existing
+//		try {
+//			f.setCarCategoryAsString("SUV"+" "); //extra blank
+//			fail("Exception was expected");
+//		} catch (RuntimeException e) {
+//		}
+//
+//	}
+	
+	@SuppressWarnings("unused")
+	public void testOwnerCompositeClass(){
+		pack1.ClasseDeTest cdt=new pack1.ClasseDeTest();
+		CompositeTargetClas ct=null;
+		// getOwner a bien ete généré automatiquement.
+		//i5=ct.getOwner();
+		Assert.fail("i5=ic.getOwner();");
+	}
+	
+	@SuppressWarnings("unused")
+	public void testOwnerCompositeInterface(){
+		pack1.ClasseDeTest cdt=new pack1.ClasseDeTest();
+		Set<InterfaceComposante> ics=cdt.getInterfaceComposante();
+		InterfaceComposante ic=null;
+		// le getOwner est généré automatiquement
+		//i5=ic.getOwner();
+		Assert.fail("i5=ic.getOwner();");
+	}
+	
+
+
+	/***************************************************************************
+	 * ************************************************************ Fin des
+	 * tests ************************************************************
+	 * ************************************************************
+	 */
+
+	public static void main(String[] args) {
+		// if(args.length==0) {
+		// junit.swingui.TestRunner.main(new String[] {"SimpleTest"});
+		// return;
+		// }
+		// if(args.length>1 || args[0]!="-textui") {
+		// System.out.println("syntaxe: [ -textui ]");
+		// System.exit(1);
+		// }
+
+		junit.textui.TestRunner.run(suite());
+		System.out.println("done");
+	}
+
+	protected static TestSuite suite() {
+		TestSuite s = new TestSuite();
+		s.addTestSuite(new RuntimeTest().getClass());
+		return s;
+	}
+}