| /******************************************************************************* |
| * <copyright> |
| * |
| * Copyright (c) 2005, 2010 SAP AG. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Stefan Dimov - initial API, implementation and documentation |
| * |
| * </copyright> |
| * |
| *******************************************************************************/ |
| package org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.util; |
| |
| import static org.easymock.EasyMock.createMock; |
| import static org.easymock.EasyMock.expect; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.util.List; |
| |
| import org.easymock.EasyMock; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IncrementalProjectBuilder; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.util.BasicInternalEList; |
| import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm; |
| import org.eclipse.graphiti.mm.algorithms.RoundedRectangle; |
| import org.eclipse.graphiti.mm.algorithms.Text; |
| import org.eclipse.graphiti.mm.pictograms.Anchor; |
| import org.eclipse.graphiti.mm.pictograms.AnchorContainer; |
| import org.eclipse.graphiti.mm.pictograms.Connection; |
| import org.eclipse.graphiti.mm.pictograms.ContainerShape; |
| import org.eclipse.graphiti.mm.pictograms.FreeFormConnection; |
| import org.eclipse.graphiti.mm.pictograms.Shape; |
| import org.eclipse.jdt.core.ICompilationUnit; |
| import org.eclipse.jdt.core.JavaCore; |
| import org.eclipse.jpt.jpa.core.JpaProject; |
| import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute; |
| import org.eclipse.jpt.jpa.core.context.java.JavaPersistentType; |
| import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentType; |
| import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.IPeServiceUtil; |
| import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants; |
| import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorUtil; |
| import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JpaArtifactFactory; |
| import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.SizePosition; |
| import org.eclipse.jpt.jpadiagrameditor.ui.internal.util.JPAEditorConstants.ShapeType; |
| import org.eclipse.jpt.jpadiagrameditor.ui.tests.internal.JPACreateFactory; |
| import org.eclipse.swt.graphics.Point; |
| import org.junit.Test; |
| |
| public class JPAEditorUtilTest { |
| @Test |
| public void testCapitalizeFirstLetter() { |
| String s = "abcdef"; |
| String res = JPAEditorUtil.capitalizeFirstLetter(s); |
| assertEquals(res.substring(0, 1), "A"); |
| assertEquals(s.substring(1), res.substring(1)); |
| } |
| |
| @Test |
| public void testDecapitalizeFirstLetter() { |
| String s = "ABCDEFGHIJK"; |
| String res = JPAEditorUtil.decapitalizeFirstLetter(s); |
| assertEquals(res.substring(0, 1), "a"); |
| assertEquals(s.substring(1), res.substring(1)); |
| } |
| |
| @Test |
| public void testRevertFirstLetterCase() { |
| String s = "ABCDEFGHIJK"; |
| String res = JPAEditorUtil.revertFirstLetterCase(s); |
| assertEquals(res.substring(0, 1), "a"); |
| assertEquals(s.substring(1), res.substring(1)); |
| String res1 = JPAEditorUtil.revertFirstLetterCase(res); |
| assertEquals(res1.substring(0, 1), "A"); |
| assertEquals(res1.substring(1), res.substring(1)); |
| } |
| |
| @Test |
| public void testEqualsIgnoreFirstLetterCase() { |
| String s1 = "abcdefg"; |
| String s2 = "Abcdefg"; |
| assertTrue(JPAEditorUtil.equalsIgnoreFirstLetterCase(s1, s2)); |
| |
| s1 = ""; |
| s2 = ""; |
| assertTrue(JPAEditorUtil.equalsIgnoreFirstLetterCase(s1, s2)); |
| |
| s1 = "gjgIyguiyGUYuGUYGuyg"; |
| s2 = "gjgIyguiyGUYuGUYGuyg"; |
| assertTrue(JPAEditorUtil.equalsIgnoreFirstLetterCase(s1, s2)); |
| |
| s1 = "LjgIyguiyGUYuGUYGuyg"; |
| s2 = "LjgIyguiyGUYuGUYGuyg"; |
| assertTrue(JPAEditorUtil.equalsIgnoreFirstLetterCase(s1, s2)); |
| |
| s1 = "gjgIyguiyGUYuGUYGuygs"; |
| s2 = "gjgIyguiyGUYuGUYGuyg"; |
| assertFalse(JPAEditorUtil.equalsIgnoreFirstLetterCase(s1, s2)); |
| |
| s1 = "LjgIyguiyGUyuGUYGuyg"; |
| s2 = "LjgIyguiyGUYuGUYGuyg"; |
| assertFalse(JPAEditorUtil.equalsIgnoreFirstLetterCase(s1, s2)); |
| } |
| |
| @Test |
| public void testReturnSimpleName() { |
| String s = ""; |
| String res = JPAEditorUtil.returnSimpleName(s); |
| assertEquals(s, res); |
| s = "jdhksajhdk"; |
| res = JPAEditorUtil.returnSimpleName(s); |
| assertEquals(s, res); |
| s = "jdhksajhdk."; |
| res = JPAEditorUtil.returnSimpleName(s); |
| assertEquals("", res); |
| s = ".jdhksajhdk"; |
| res = JPAEditorUtil.returnSimpleName(s); |
| assertEquals("jdhksajhdk", res); |
| s = "jdhks.ajhdk"; |
| res = JPAEditorUtil.returnSimpleName(s); |
| assertEquals("ajhdk", res); |
| s = "dss.dsdsd.jd.hks.ajhdk"; |
| res = JPAEditorUtil.returnSimpleName(s); |
| assertEquals("ajhdk", res); |
| } |
| |
| |
| @Test |
| public void testStripQuotes() { |
| String s = ""; |
| String res = JPAEditorUtil.stripQuotes(s); |
| assertEquals("", res); |
| |
| s = "\"\""; |
| res = JPAEditorUtil.stripQuotes(s); |
| assertEquals("", res); |
| |
| s = "\"fdsjfjslkdjflks\""; |
| res = JPAEditorUtil.stripQuotes(s); |
| assertEquals("fdsjfjslkdjflks", res); |
| |
| s = "\"fdsjfjslkdjflks"; |
| res = JPAEditorUtil.stripQuotes(s); |
| assertEquals("\"fdsjfjslkdjflks", res); |
| |
| s = "fdsjfjslkdjflks\""; |
| res = JPAEditorUtil.stripQuotes(s); |
| assertEquals("fdsjfjslkdjflks\"", res); |
| } |
| |
| //@Test |
| public void testGetJPType() throws Exception { |
| |
| String TEST_PROJECT = "Test"; |
| JpaProject jpaProject = null; |
| JPACreateFactory factory = null; |
| String testProjectName = TEST_PROJECT + "_" + System.currentTimeMillis(); |
| |
| factory = JPACreateFactory.instance(); |
| jpaProject = factory.createJPAProject(testProjectName); |
| assertNotNull(jpaProject); |
| Thread.sleep(2000); |
| |
| assertNotNull(jpaProject); |
| IFile customerFile = factory.createEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer"); |
| |
| jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor()); |
| |
| assertTrue(customerFile.exists()); |
| JavaResourcePersistentType customerType = jpaProject.getJavaResourcePersistentType("com.test.Customer"); |
| assertNotNull(customerType); |
| |
| ICompilationUnit cu = createCompilationUnitFrom(customerFile); |
| Thread.sleep(2000); |
| JavaPersistentType jpt = JPAEditorUtil.getJPType(cu); |
| assertEquals(customerType.getQualifiedName(), jpt.getName()); |
| } |
| |
| @Test |
| public void testProduceValidAttributeName() { |
| String s = "a"; |
| String res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals(s, res); |
| |
| s = "A"; |
| res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals("a", res); |
| |
| s = "aT"; |
| res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals("AT", res); |
| |
| s = "At"; |
| res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals("at", res); |
| |
| s = "AT"; |
| res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals("AT", res); |
| |
| s = "a1"; |
| res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals("a1", res); |
| |
| s = "A1"; |
| res = JPAEditorUtil.produceValidAttributeName(s); |
| assertEquals("a1", res); |
| |
| } |
| |
| //@Test |
| public void testCreateImports() throws Exception { |
| String TEST_PROJECT = "Test"; |
| JpaProject jpaProject = null; |
| JPACreateFactory factory = null; |
| String testProjectName = TEST_PROJECT + "_" + System.currentTimeMillis(); |
| |
| factory = JPACreateFactory.instance(); |
| jpaProject = factory.createJPAProject(testProjectName); |
| assertNotNull(jpaProject); |
| Thread.sleep(2000); |
| |
| assertNotNull(jpaProject); |
| IFile customerFile = factory.createEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer"); |
| jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor()); |
| |
| assertTrue(customerFile.exists()); |
| JavaResourcePersistentType customerType = jpaProject.getJavaResourcePersistentType("com.test.Customer"); |
| assertNotNull(customerType); |
| |
| ICompilationUnit cu = createCompilationUnitFrom(customerFile); |
| |
| JPAEditorUtil.createImports(cu, "java.util.Hashtable<java.lang.StringBuffer,java.lang.Set<java.lang.String>>"); |
| } |
| |
| @Test |
| public void testSizePosition() { |
| SizePosition sp = new SizePosition(1,2,3,4); |
| assertTrue(sp.getWidth() == 1); |
| assertTrue(sp.getHeight() == 2); |
| assertTrue(sp.getX() == 3); |
| assertTrue(sp.getY() == 4); |
| } |
| |
| //@Test |
| public void testGetText() throws Exception { |
| String TEST_PROJECT = "Test"; |
| JpaProject jpaProject = null; |
| JPACreateFactory factory = null; |
| String testProjectName = TEST_PROJECT + "_" + System.currentTimeMillis(); |
| |
| factory = JPACreateFactory.instance(); |
| jpaProject = factory.createJPAProject(testProjectName); |
| assertNotNull(jpaProject); |
| Thread.sleep(2000); |
| |
| assertNotNull(jpaProject); |
| IFile customerFile = factory.createEntityInProject(jpaProject.getProject(), new String[]{"com","test"}, "Customer"); |
| jpaProject.getProject().build(IncrementalProjectBuilder.CLEAN_BUILD, new NullProgressMonitor()); |
| |
| assertTrue(customerFile.exists()); |
| JavaResourcePersistentType customerType = jpaProject.getJavaResourcePersistentType("com.test.Customer"); |
| assertNotNull(customerType); |
| |
| JavaPersistentType t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName()); |
| int cnt = 0; |
| while ((cnt < 25) && (t1 == null)) { |
| Thread.sleep(200); |
| t1 = JpaArtifactFactory.instance().getContextPersistentType(jpaProject, customerType.getQualifiedName()); |
| cnt++; |
| } |
| if (t1 == null) |
| return; |
| assertNotNull(JPAEditorUtil.getText(t1)); |
| assertNotNull(JPAEditorUtil.getTooltipText(t1)); |
| JavaPersistentAttribute jpa = t1.getAttributeNamed("id"); |
| assertNotNull(jpa); |
| assertNotNull(JPAEditorUtil.getText(jpa)); |
| assertNotNull(JPAEditorUtil.getTooltipText(jpa)); |
| |
| } |
| |
| //@Test |
| public void testSetJPTNameInShape() { |
| final String NEW_NAME = "NewJPTName"; |
| ContainerShape cs = EasyMock.createMock(ContainerShape.class); |
| Shape sh = EasyMock.createMock(Shape.class); |
| GraphicsAlgorithm ga = EasyMock.createMock(GraphicsAlgorithm.class); |
| IPeServiceUtil peUtil = EasyMock.createMock(IPeServiceUtil.class); |
| EasyMock.expect(peUtil.getPropertyValue(sh, JPAEditorConstants.PROP_SHAPE_TYPE)).andStubReturn(ShapeType.HEADER.toString()); |
| EList<Shape> shapes = new BasicInternalEList<Shape>(Shape.class); |
| shapes.add(sh); |
| EasyMock.expect(cs.getChildren()).andStubReturn(shapes); |
| Text txt = EasyMock.createMock(Text.class); |
| EList<GraphicsAlgorithm> gaCh = new BasicInternalEList<GraphicsAlgorithm>(GraphicsAlgorithm.class); |
| gaCh.add(txt); |
| EasyMock.expect(sh.getGraphicsAlgorithm()).andStubReturn(ga); |
| EasyMock.expect(ga.getGraphicsAlgorithmChildren()).andStubReturn(gaCh); |
| txt.setValue(NEW_NAME); |
| EasyMock.replay(cs, sh, ga, peUtil, txt); |
| JPAEditorUtil.setJPTNameInShape(cs, NEW_NAME, peUtil); |
| } |
| |
| //@Test |
| public void testCreateBendPointList1() { |
| FreeFormConnection c = EasyMock.createMock(FreeFormConnection.class); |
| Anchor startAnchor = EasyMock.createMock(Anchor.class); |
| Anchor endAnchor = EasyMock.createMock(Anchor.class); |
| AnchorContainer startAnchorContainer = EasyMock.createMock(AnchorContainer.class); |
| AnchorContainer endAnchorContainer = EasyMock.createMock(AnchorContainer.class); |
| expect(c.getStart()).andStubReturn(startAnchor); |
| expect(c.getEnd()).andStubReturn(endAnchor); |
| expect(startAnchor.getParent()).andStubReturn(startAnchorContainer); |
| expect(endAnchor.getParent()).andStubReturn(endAnchorContainer); |
| RoundedRectangle rectStart = createMock(RoundedRectangle.class); |
| RoundedRectangle rectEnd = createMock(RoundedRectangle.class); |
| expect(startAnchorContainer.getGraphicsAlgorithm()).andStubReturn(rectStart); |
| expect(endAnchorContainer.getGraphicsAlgorithm()).andStubReturn(rectEnd); |
| expect(rectStart.getX()).andStubReturn(100); |
| expect(rectStart.getY()).andStubReturn(100); |
| expect(rectStart.getWidth()).andStubReturn(200); |
| expect(rectStart.getHeight()).andStubReturn(120); |
| expect(rectEnd.getX()).andStubReturn(100); |
| expect(rectEnd.getY()).andStubReturn(800); |
| expect(rectEnd.getWidth()).andStubReturn(200); |
| expect(rectEnd.getHeight()).andStubReturn(120); |
| |
| EList<Connection> ccc = new BasicInternalEList<Connection>(Connection.class); |
| expect(startAnchor.getOutgoingConnections()).andStubReturn(ccc); |
| expect(endAnchor.getOutgoingConnections()).andStubReturn(ccc); |
| |
| EasyMock.replay(c, startAnchor, endAnchor, startAnchorContainer, endAnchorContainer, rectStart, rectEnd); |
| |
| |
| |
| List<Point> lst = JPAEditorUtil.createBendPointList(c, false); |
| assertTrue(lst.size() == 2); |
| for (Point p : lst) { |
| assertTrue(p.x >= 0); |
| assertTrue(p.y >= 0); |
| |
| assertTrue(p.x <= 1000000); |
| assertTrue(p.y <= 1000000); |
| } |
| |
| } |
| |
| //@Test |
| public void testCreateBendPointList2() { |
| FreeFormConnection c = EasyMock.createMock(FreeFormConnection.class); |
| Anchor startAnchor = EasyMock.createMock(Anchor.class); |
| Anchor endAnchor = EasyMock.createMock(Anchor.class); |
| AnchorContainer startAnchorContainer = EasyMock.createMock(AnchorContainer.class); |
| AnchorContainer endAnchorContainer = EasyMock.createMock(AnchorContainer.class); |
| expect(c.getStart()).andStubReturn(startAnchor); |
| expect(c.getEnd()).andStubReturn(endAnchor); |
| expect(startAnchor.getParent()).andStubReturn(startAnchorContainer); |
| expect(endAnchor.getParent()).andStubReturn(endAnchorContainer); |
| RoundedRectangle rectStart = createMock(RoundedRectangle.class); |
| RoundedRectangle rectEnd = createMock(RoundedRectangle.class); |
| expect(startAnchorContainer.getGraphicsAlgorithm()).andStubReturn(rectStart); |
| expect(endAnchorContainer.getGraphicsAlgorithm()).andStubReturn(rectEnd); |
| expect(rectStart.getX()).andStubReturn(100); |
| expect(rectStart.getY()).andStubReturn(100); |
| expect(rectStart.getWidth()).andStubReturn(200); |
| expect(rectStart.getHeight()).andStubReturn(120); |
| expect(rectEnd.getX()).andStubReturn(800); |
| expect(rectEnd.getY()).andStubReturn(100); |
| expect(rectEnd.getWidth()).andStubReturn(200); |
| expect(rectEnd.getHeight()).andStubReturn(120); |
| |
| EList<Connection> ccc = new BasicInternalEList<Connection>(Connection.class); |
| expect(startAnchor.getOutgoingConnections()).andStubReturn(ccc); |
| expect(endAnchor.getOutgoingConnections()).andStubReturn(ccc); |
| |
| EasyMock.replay(c, startAnchor, endAnchor, startAnchorContainer, endAnchorContainer, rectStart, rectEnd); |
| |
| List<Point> lst = JPAEditorUtil.createBendPointList(c, false); |
| assertTrue(lst.size() == 2); |
| for (Point p : lst) { |
| assertTrue(p.x >= 0); |
| assertTrue(p.y >= 0); |
| |
| assertTrue(p.x <= 1000000); |
| assertTrue(p.y <= 1000000); |
| } |
| |
| } |
| |
| public ICompilationUnit createCompilationUnitFrom(IFile file) { |
| return JavaCore.createCompilationUnitFrom(file); |
| } |
| |
| @Test |
| public void testAreHeadersEqual() { |
| assertTrue(JPAEditorUtil.areHeadersEqual("header", "header")); |
| assertTrue(JPAEditorUtil.areHeadersEqual(JPAEditorConstants.HEADER_PREFIX_DIRTY + "header", "header")); |
| assertTrue(JPAEditorUtil.areHeadersEqual("header", JPAEditorConstants.HEADER_PREFIX_DIRTY + "header")); |
| |
| assertFalse(JPAEditorUtil.areHeadersEqual("header", "headers")); |
| assertFalse(JPAEditorUtil.areHeadersEqual("headers", "header")); |
| |
| assertFalse(JPAEditorUtil.areHeadersEqual(JPAEditorConstants.HEADER_PREFIX_DIRTY + "headers", "header")); |
| assertFalse(JPAEditorUtil.areHeadersEqual(JPAEditorConstants.HEADER_PREFIX_DIRTY + "header", "headers")); |
| |
| assertFalse(JPAEditorUtil.areHeadersEqual("headers", JPAEditorConstants.HEADER_PREFIX_DIRTY + "header")); |
| assertFalse(JPAEditorUtil.areHeadersEqual("header", JPAEditorConstants.HEADER_PREFIX_DIRTY + "headers")); |
| } |
| |
| } |
