tests/org.simantics.db.tests/src/org/simantics/db/tests/api/story/misc/SyntheticModellingTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management
   3  * in Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.db.tests.api.story.misc;
  13
  14 import gnu.trove.set.hash.THashSet;
  15
  16 import java.util.ArrayList;
  17 import java.util.Random;
  18
  19 import org.junit.Test;
  20 import org.simantics.db.Resource;
  21 import org.simantics.db.Session;
  22 import org.simantics.db.WriteGraph;
  23 import org.simantics.db.common.request.WriteRequest;
  24 import org.simantics.db.exception.DatabaseException;
  25 import org.simantics.db.testing.annotation.Fails;
  26 import org.simantics.db.testing.base.ExistingDatabaseTest;
  27 import org.simantics.db.tests.common.Configuration;
  28 import org.simantics.layer0.Layer0;
  29 import org.simantics.project.ontology.ProjectResource;
  30
  31 public class SyntheticModellingTest extends ExistingDatabaseTest {
  32
  33         static int LOOP_COUNT = Configuration.get().modellingLoopCount;
  34         static int OP_COUNT = Configuration.get().modellingOpCount;
  35         Session session;
  36         Resource root;
  37         Layer0 b;
  38
  39         Resource Component;
  40         Resource Composite;
  41         Resource IsDefinedBy;
  42         Resource Connection;
  43         Resource IsConnected;
  44         Resource IsConnectedTo;
  45         Resource IsConnectedFrom;
  46
  47         int componentTypeCount = 0;
  48         int componentCount = 0;
  49         int connectionCount = 0;
  50
  51         static class Component {
  52                 Resource resource;
  53                 ComponentType type;
  54         }
  55
  56         static class ComponentType {
  57                 Resource resource;
  58                 Resource composite;
  59                 ArrayList<Component> components = new ArrayList<Component>();
  60                 ArrayList<Resource> connections = new ArrayList<Resource>();
  61         }
  62
  63         ArrayList<ComponentType> componentTypes = new ArrayList<ComponentType>();
  64
  65         Random random = new Random(0x12345679);
  66
  67 //      @Override
  68 //      protected void setUp() throws Exception {
  69 //              SessionFactory factory = new SessionFactory(Configuration.get().host, Configuration.get().port);
  70 //              session = factory.create();
  71 //      }
  72 //
  73 //      @Override
  74 //      protected void tearDown() throws Exception {
  75 //              LifecycleSupport support = session.getService(LifecycleSupport.class);
  76 //              support.close();
  77 //      }
  78
  79         class SetUp extends WriteRequest {
  80
  81                 @Override
  82                 public void perform(WriteGraph g) throws DatabaseException {
  83
  84                         b = Layer0.getInstance(g);
  85
  86                         ProjectResource PROJ = ProjectResource.getInstance(g);
  87
  88                         root = g.newResource();
  89                         g.claim(root, b.InstanceOf, PROJ.Project);
  90
  91                         Component = g.getResource("http://www.simantics.org/Structural-1.0/Component");
  92                         Composite = g.getResource("http://www.simantics.org/Structural-1.0/Composite");
  93                         IsDefinedBy = g.getResource("http://www.simantics.org/Structural-1.0/IsDefinedBy");
  94                         Connection = g.getResource("http://www.simantics.org/Structural-1.0/Connection");
  95                         IsConnected = g.getResource("http://www.simantics.org/Structural-1.0/IsConnected");
  96                         IsConnectedTo = g.getResource("http://www.simantics.org/Structural-1.0/IsConnectedTo");
  97                         IsConnectedFrom = g.getResource("http://www.simantics.org/Structural-1.0/IsConnectedFrom");
  98
  99                 }
 100
 101         }
 102
 103         class NewComponentType extends WriteRequest {
 104
 105                 @Override
 106                 public void perform(WriteGraph g) throws DatabaseException {
 107                         ComponentType componentType = new ComponentType();
 108
 109                         componentType.resource = g.newResource();
 110                         g.claim(componentType.resource, b.Inherits, Component);
 111                         g.claim(root, b.ConsistsOf, componentType.resource);
 112                         g.claimLiteral(componentType.resource, b.HasName, "ComponentType" + componentType.resource.getResourceId());
 113
 114                         componentType.composite = g.newResource();
 115                         g.claim(componentType.composite, b.Inherits, Composite);
 116                         g.claim(componentType.resource, IsDefinedBy, componentType.composite);
 117
 118                         componentTypes.add(componentType);
 119
 120                         ++componentTypeCount;
 121                 }
 122
 123         }
 124
 125         class NewComponent extends WriteRequest {
 126
 127                 @Override
 128                 public void perform(WriteGraph g) throws DatabaseException {
 129                         ComponentType componentType = componentTypes.get(random.nextInt(componentTypes.size()));
 130                         ComponentType containerType = componentTypes.get(random.nextInt(componentTypes.size()));
 131
 132                         Component component = new Component();
 133
 134                         component.resource = g.newResource();
 135                         g.claim(component.resource, b.InstanceOf, componentType.resource);
 136                         g.claim(containerType.composite, b.ConsistsOf, component.resource);
 137
 138                         g.claimLiteral(component.resource, b.HasName, "Component" + componentType.resource.getResourceId());
 139
 140                         containerType.components.add(component);
 141
 142                         ++componentCount;
 143                 }
 144
 145         }
 146
 147         class RemoveComponent extends WriteRequest {
 148
 149                 @Override
 150                 public void perform(WriteGraph g) throws DatabaseException {
 151                         ComponentType containerType = componentTypes.get(random.nextInt(componentTypes.size()));
 152                         if(containerType.components.isEmpty())
 153                                 return;
 154                         int cid = random.nextInt(containerType.components.size());
 155                         Component component = containerType.components.get(cid);
 156                         THashSet<Resource> removed = new THashSet<Resource>();
 157                         for(Resource c : g.getObjects(component.resource, IsConnected))
 158                                 if(removed.add(c)) {
 159                                         g.deny(c);
 160                                         int id = containerType.connections.indexOf(c);
 161                                         int last = containerType.connections.size()-1;
 162                                         if(id < last)
 163                                                 containerType.connections.set(id, containerType.connections.remove(last));
 164                                         else
 165                                                 containerType.connections.remove(last);
 166                                         --connectionCount;
 167                                 }
 168                         g.deny(component.resource);
 169                         {
 170                                 int last = containerType.components.size() - 1;
 171                                 if(cid < last)
 172                                         containerType.components.set(cid, containerType.components.remove(last));
 173                                 else
 174                                         containerType.components.remove(last);
 175                         }
 176
 177                         --componentCount;
 178                 }
 179
 180         }
 181
 182         class NewConnection extends WriteRequest {
 183
 184                 @Override
 185                 public void perform(WriteGraph g) throws DatabaseException {
 186                         ComponentType containerType = componentTypes.get(random.nextInt(componentTypes.size()));
 187                         if(containerType.components.isEmpty())
 188                                 return;
 189
 190                         Component c1 = containerType.components.get(random.nextInt(containerType.components.size()));
 191                         Component c2 = containerType.components.get(random.nextInt(containerType.components.size()));
 192
 193                         Resource connection = g.newResource();
 194                         g.claim(connection, b.InstanceOf, Connection);
 195                         g.claim(c1.resource, IsConnectedTo, connection);
 196                         g.claim(c2.resource, IsConnectedFrom, connection);
 197
 198                         containerType.connections.add(connection);
 199
 200                         ++connectionCount;
 201                 }
 202
 203         }
 204
 205         class RemoveConnection extends WriteRequest {
 206
 207                 @Override
 208                 public void perform(WriteGraph g) throws DatabaseException {
 209                         ComponentType containerType = componentTypes.get(random.nextInt(componentTypes.size()));
 210                         if(containerType.connections.isEmpty())
 211                                 return;
 212
 213                         int id = random.nextInt(containerType.connections.size());
 214                         g.deny(containerType.connections.get(id));
 215                         int last = containerType.connections.size()-1;
 216                         if(id < last)
 217                                 containerType.connections.set(id, containerType.connections.remove(last));
 218                         else
 219                                 containerType.connections.remove(last);
 220
 221                         --connectionCount;
 222                 }
 223
 224         }
 225
 226         @Fails
 227         @Test public void test() {
 228                 try {
 229                         session = getSession();
 230                         session.syncRequest(new SetUp());
 231                         for(int i=0;i<100;++i)
 232                                 session.syncRequest(new NewComponentType());
 233                         for(int i=0;i<LOOP_COUNT;++i) {
 234                                 long startTime = System.nanoTime();
 235                                 for(int j=0;j<OP_COUNT;++j)
 236                                         switch(random.nextInt(8)) {
 237                                         case 0:
 238                                                 session.syncRequest(new NewComponent());
 239                                                 break;
 240                                         case 1:
 241                                                 session.syncRequest(new RemoveComponent());
 242                                                 break;
 243                                         case 2:
 244                                                 if(componentCount > 1000)
 245                                                         session.syncRequest(new RemoveComponent());
 246                                                 else
 247                                                         session.syncRequest(new NewComponent());
 248                                                 break;
 249                                         case 3:
 250                                                 session.syncRequest(new NewConnection());
 251                                                 break;
 252                                         case 4:
 253                                                 session.syncRequest(new RemoveConnection());
 254                                                 break;
 255                                         case 5:
 256                                         case 6:
 257                                         case 7:
 258                                                 if(connectionCount > 1000)
 259                                                         session.syncRequest(new RemoveConnection());
 260                                                 else
 261                                                         session.syncRequest(new NewConnection());
 262                                                 break;
 263                                         }
 264                                 long endTime = System.nanoTime();
 265                                 System.out.println((endTime - startTime) * 1e-9 + "s / 1000 operations");
 266                                 System.out.println(
 267                                                 componentTypeCount + " user components, " +
 268                                                 componentCount + " components, " +
 269                                                 connectionCount + " connections"
 270                                 );
 271                         }
 272                 } catch (DatabaseException e) {
 273                     if (DEBUG)
 274                         e.printStackTrace();
 275                     fail("Test failed with: " + e.getMessage());
 276                 }
 277         }
 278
 279 }