bundles/org.simantics.history/test/org/simantics/history/test/TestHistory.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2011 Association for Decentralized Information Management in\r
   3  * Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.history.test;\r
  13 \r
  14 import java.io.ByteArrayInputStream;\r
  15 import java.io.ByteArrayOutputStream;\r
  16 import java.io.File;\r
  17 import java.io.IOException;\r
  18 \r
  19 import org.junit.After;\r
  20 import org.junit.Assert;\r
  21 import org.junit.Before;\r
  22 import org.junit.Test;\r
  23 import org.simantics.databoard.Bindings;\r
  24 import org.simantics.databoard.Datatypes;\r
  25 import org.simantics.databoard.accessor.StreamAccessor;\r
  26 import org.simantics.databoard.accessor.error.AccessorException;\r
  27 import org.simantics.databoard.binding.Binding;\r
  28 import org.simantics.databoard.binding.impl.DoubleArrayBinding;\r
  29 import org.simantics.databoard.type.ArrayType;\r
  30 import org.simantics.databoard.type.RecordType;\r
  31 import org.simantics.databoard.util.Bean;\r
  32 import org.simantics.databoard.util.Limit;\r
  33 import org.simantics.databoard.util.Range;\r
  34 import org.simantics.history.Collector;\r
  35 import org.simantics.history.History;\r
  36 import org.simantics.history.HistoryException;\r
  37 import org.simantics.history.HistoryManager;\r
  38 import org.simantics.history.csv.CSVFormatter;\r
  39 import org.simantics.history.impl.CollectorImpl;\r
  40 import org.simantics.history.impl.CollectorState;\r
  41 import org.simantics.history.util.ProgressMonitor;\r
  42 import org.simantics.history.util.StreamIterator;\r
  43 import org.simantics.history.util.Stream;\r
  44 import org.simantics.history.util.ValueBand;\r
  45 import org.simantics.history.util.subscription.SubscriptionItem;\r
  46 import org.simantics.history.util.subscription.SamplingFormat;\r
  47 import org.simantics.utils.FileUtils;\r
  48 \r
  49 public class TestHistory {\r
  50         \r
  51         static final double NaN = Double.NaN;\r
  52         \r
  53         // Time            0.0  0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.0  1.1  1.2  1.3  1.4\r
  54         double[] data1 = { 5.0, 5.0, 5.0, 5.0, 6.0, 6.0, 6.0, 7.0, 8.0, 9.0, NaN,10.0, NaN, NaN, NaN }; \r
  55         double[] data2 = { 5.0, 5.0, 5.0, 5.0, 6.0, 6.0, 6.0, 7.0, 8.0, 9.0,10.0, 9.0, 5.0, 4.0, 3.0 };\r
  56         byte[] data3 = { 5, 6, 7, 8, 9, 10, 9, 5, 4, 3 };\r
  57         \r
  58         // Subscription formats\r
  59         SamplingFormat simple, allfields, vector, minmax, byteformat, string;\r
  60 \r
  61         // History\r
  62         HistoryManager historian;\r
  63         File workarea;\r
  64         Collector collector;\r
  65 \r
  66         @Before \r
  67         public void initSubscriptionFormats()\r
  68         {\r
  69                 simple = new SamplingFormat();\r
  70                 simple.formatId = "simple";\r
  71                 RecordType format;\r
  72                 format = (RecordType) (simple.format = new RecordType());\r
  73                 format.addComponent("time", Datatypes.FLOAT);\r
  74                 format.addComponent("endTime", Datatypes.FLOAT);\r
  75                 format.addComponent("value", Datatypes.DOUBLE );\r
  76                 format.addComponent("quality", Datatypes.BYTE );\r
  77                 simple.interval = NaN;\r
  78                 simple.deadband = NaN;\r
  79 \r
  80                 string = new SamplingFormat();\r
  81                 string.formatId = "string";\r
  82                 format = (RecordType) (string.format = new RecordType());\r
  83                 format.addComponent("time", Datatypes.FLOAT);\r
  84                 format.addComponent("endTime", Datatypes.FLOAT);\r
  85                 format.addComponent("value", Datatypes.STRING );\r
  86                 format.addComponent("quality", Datatypes.BYTE );\r
  87                 string.interval = NaN;\r
  88                 string.deadband = NaN;\r
  89                 \r
  90                 allfields = new SamplingFormat();\r
  91                 allfields.formatId = "alldata"; \r
  92                 format = (RecordType) (allfields.format = new RecordType());\r
  93                 format.addComponent("time", Datatypes.DOUBLE);\r
  94                 format.addComponent("endTime", Datatypes.DOUBLE);\r
  95                 format.addComponent("value", Datatypes.DOUBLE );\r
  96                 format.addComponent("lastValue", Datatypes.DOUBLE);             \r
  97                 format.addComponent("min", Datatypes.DOUBLE);\r
  98                 format.addComponent("max", Datatypes.DOUBLE);\r
  99                 format.addComponent("avg", Datatypes.DOUBLE);\r
 100                 format.addComponent("median", Datatypes.DOUBLE);\r
 101                 format.addComponent("quality", Datatypes.BYTE );\r
 102                 format.addComponent("count", Datatypes.INTEGER);\r
 103                 allfields.interval = NaN;\r
 104                 allfields.deadband = NaN;               \r
 105 \r
 106                 byteformat = new SamplingFormat();\r
 107                 byteformat.formatId = "byte";\r
 108                 byteformat.format = new RecordType();\r
 109                 format = (RecordType) (byteformat.format = new RecordType());\r
 110                 format.addComponent("time", Datatypes.DOUBLE);\r
 111                 format.addComponent("endTime", Datatypes.DOUBLE);\r
 112                 format.addComponent("value", Datatypes.BYTE);\r
 113                 format.addComponent("lastValue", Datatypes.BYTE);               \r
 114                 format.addComponent("min", Datatypes.BYTE);\r
 115                 format.addComponent("max", Datatypes.BYTE);\r
 116                 format.addComponent("avg", Datatypes.DOUBLE);\r
 117                 format.addComponent("median", Datatypes.BYTE);\r
 118                 format.addComponent("quality", Datatypes.BYTE);\r
 119                 format.addComponent("count", Datatypes.INTEGER);\r
 120                 byteformat.interval = NaN;\r
 121                 byteformat.deadband = NaN;              \r
 122                 \r
 123                 vector = new SamplingFormat();\r
 124                 vector.formatId = "vector";\r
 125                 vector.format = new RecordType();\r
 126                 format = (RecordType) (vector.format = new RecordType());\r
 127                 format.addComponent("time", Datatypes.FLOAT);\r
 128                 format.addComponent("endTime", Datatypes.FLOAT);\r
 129                 format.addComponent("value", new ArrayType( Datatypes.DOUBLE, Range.between(Limit.inclusive(3), Limit.inclusive(3)) ));\r
 130                 format.addComponent("count", Datatypes.INTEGER);\r
 131                 vector.interval = NaN;\r
 132                 vector.deadband = NaN;\r
 133                 \r
 134                 minmax = new SamplingFormat();\r
 135                 minmax.formatId = "minmax";\r
 136                 minmax.format = new RecordType();\r
 137                 format = (RecordType) (minmax.format = new RecordType());\r
 138                 format.addComponent("time", Datatypes.FLOAT);\r
 139                 format.addComponent("endTime", Datatypes.FLOAT);\r
 140                 format.addComponent("value", Datatypes.DOUBLE );\r
 141                 format.addComponent("min", Datatypes.DOUBLE );\r
 142                 format.addComponent("max", Datatypes.DOUBLE );\r
 143                 minmax.interval = Double.MAX_VALUE;\r
 144                 minmax.deadband = Double.MAX_VALUE;             \r
 145         }\r
 146 \r
 147         @Before\r
 148         public void initHistory() {\r
 149                 CollectorState cs = new CollectorState();\r
 150                 workarea = FileUtils.createTmpDir();\r
 151                 System.out.println(workarea);\r
 152                 historian = History.openFileHistory( workarea );\r
 153 //              historian = History.createMemoryHistory();\r
 154                 collector = new CollectorImpl( historian );\r
 155         }\r
 156         \r
 157         @After \r
 158         public void uninitHistory() {\r
 159                 if ( collector != null ) {\r
 160                         collector.close();                      \r
 161                 }\r
 162                 if ( historian != null ) {\r
 163                         historian.close();\r
 164                 }\r
 165                 if ( workarea != null) {\r
 166                         try {\r
 167                                 FileUtils.deleteAll(workarea);\r
 168                         } catch (IOException e) {\r
 169                                 e.printStackTrace();\r
 170                         }\r
 171                 }\r
 172         }\r
 173         \r
 174         @Test\r
 175         public void testGetModifySubscription() throws Exception\r
 176         {\r
 177                 // 1. Create Item and Collector\r
 178                 SubscriptionItem hi = SubscriptionItem.createItem("NotMyVariable", "MySubscription", allfields);\r
 179                 historian.create(hi);\r
 180                 collector.addItem(hi);\r
 181                 \r
 182                 // 2. Get Item\r
 183                 SubscriptionItem[] items = collector.getItems();                \r
 184                 Assert.assertEquals(1, items.length);\r
 185                 SubscriptionItem hii = new SubscriptionItem();\r
 186                 hii.readAvailableFields( items[0] );\r
 187                 Assert.assertTrue( hii.equalContents( hi ) );\r
 188                 \r
 189                 // 3. Modify Item\r
 190                 hi.variableId = "MyVariable";\r
 191                 collector.setItem(hi);\r
 192                 items = collector.getItems();           \r
 193                 Assert.assertEquals(1, items.length);\r
 194                 hii.readAvailableFields( items[0] );\r
 195                 Assert.assertTrue( hii.equalContents( hi ) );\r
 196                 \r
 197                 // 4. Remove & Add\r
 198                 collector.removeItem(hi.id);\r
 199                 Assert.assertEquals(0, collector.getItems().length);\r
 200                 collector.addItem(hi);\r
 201                 \r
 202                 // 5. Open & Modify subscription\r
 203                 collector.beginStep(Bindings.DOUBLE, 5.0);\r
 204                 hi.interval = 1.2;\r
 205                 collector.setItem(hi);\r
 206                 collector.endStep();\r
 207                 collector.close();\r
 208 \r
 209                 // 6. Read from history\r
 210                 Bean bean = historian.getItem(hi.id);\r
 211                 hi.interval = 0.0;\r
 212                 hi.readAvailableFields(bean);\r
 213                 Assert.assertEquals(1.2, hi.interval, 0.1);\r
 214         }\r
 215 \r
 216         @Test\r
 217         public void failtestRecreateSubscription() throws HistoryException\r
 218         {\r
 219                 Collector collector2;\r
 220                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", allfields);\r
 221                 historian.create(hi);\r
 222                 \r
 223                 collector.addItem( hi );\r
 224                 collector2 = new CollectorImpl( historian );\r
 225                 collector2.addItem( hi );\r
 226                 \r
 227                 try {\r
 228                         collector.beginStep(Bindings.DOUBLE, 0.0);\r
 229                         collector2.beginStep(Bindings.DOUBLE, 0.0);\r
 230                         Assert.fail("Recreate subscription should have failed");\r
 231                 } catch (HistoryException e) {\r
 232                         // expected exception\r
 233                 }\r
 234         \r
 235                 collector2.close();\r
 236         }\r
 237 \r
 238         @Test\r
 239         public void failtestReopenStream() throws HistoryException\r
 240         {\r
 241                 // 1. Create history and collector item\r
 242                 SamplingFormat format = allfields.clone();\r
 243                 format.deadband = 2.5;\r
 244                 SubscriptionItem[] his = SubscriptionItem.createItems("MyVariable", "MySubscription", allfields, minmax);\r
 245                 historian.create(his);\r
 246                 StreamAccessor sa1=null, sa2=null;\r
 247                 try {\r
 248                         sa1 = historian.openStream(his[0].id, "r");\r
 249                         sa2 = historian.openStream(his[1].id, "r");\r
 250                         Assert.fail("HistoryManager must not allow to open two handles to same subscription");\r
 251                 } catch (HistoryException he) {\r
 252                         // Expected exception\r
 253                 }\r
 254                 try {\r
 255                 if (sa1!=null)sa1.close();\r
 256                 if (sa2!=null) sa2.close();\r
 257                 } catch (AccessorException e) {\r
 258                         throw new HistoryException(e);\r
 259                 }\r
 260                 \r
 261                 historian.delete( his[0].id, his[1].id );\r
 262         }\r
 263         \r
 264         @Test\r
 265         public void testDisableItem() throws Exception {\r
 266                 // 1. Create history and collector item\r
 267                 SamplingFormat format = allfields.clone();\r
 268                 format.deadband = 2.5;\r
 269                 SubscriptionItem[] hi = SubscriptionItem.createItems("MyVariable", "MySubscription", allfields, minmax);\r
 270                 historian.create(hi);           \r
 271                 \r
 272                 // 2. Create collector\r
 273                 collector.addItems(hi);\r
 274                 \r
 275                 // Write data\r
 276                 try {\r
 277                         // Simulate\r
 278                         double[] data = data1;\r
 279                         for (int i=0; i<4; i++) \r
 280                         {\r
 281                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 282                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 283                                 collector.endStep();\r
 284                         }\r
 285                         \r
 286                         // Disable item\r
 287                         hi[0].enabled = false;\r
 288                         collector.setItem(hi[0]);\r
 289                         for (int i=4; i<12; i++) \r
 290                         {\r
 291                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 292                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 293                                 collector.endStep();\r
 294                         }\r
 295                         \r
 296                         // Enable item\r
 297                         hi[0].enabled = true;\r
 298                         collector.setItem(hi[0]);\r
 299                         for (int i=12; i<data.length; i++) \r
 300                         {\r
 301                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 302                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 303                                 collector.endStep();\r
 304                         }                       \r
 305                         \r
 306                 } finally {\r
 307                         collector.close();\r
 308                 }\r
 309                 \r
 310                 \r
 311                 // 3. Verify data\r
 312                 StreamAccessor aa = historian.openStream(hi[0].id, "r");\r
 313                 try {\r
 314                         Binding sampleBinding = Bindings.getBinding( allfields.format );\r
 315                         \r
 316                         // Read and assert the sample\r
 317                         Object sample = aa.get(0, sampleBinding);\r
 318                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 319                         if (se.supportsNullValue()) { \r
 320                                 Assert.assertEquals(0.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 321                                 Assert.assertEquals(0.3, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 322                                 Assert.assertFalse( se.isNullValue() );\r
 323                                 \r
 324                                 aa.get(1, sampleBinding, sample);\r
 325                                 Assert.assertEquals(0.4, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 326                                 Assert.assertEquals(1.1, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 327                                 Assert.assertTrue( se.isNullValue() );\r
 328         \r
 329                                 aa.get(2, sampleBinding, sample);                       \r
 330                                 Assert.assertEquals(1.2, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 331                         }\r
 332                         \r
 333                 } finally {\r
 334                         aa.close();\r
 335                 }\r
 336 \r
 337                 // 4. Verify min-max has only 1 sample\r
 338                 aa = historian.openStream(hi[1].id, "r");\r
 339                 try {\r
 340                         Assert.assertEquals(1, aa.size());\r
 341                         Binding sampleBinding = Bindings.getBinding( minmax.format );\r
 342                         \r
 343                         // Read and assert the sample\r
 344                         Object sample = aa.get(0, sampleBinding);\r
 345                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 346                         Assert.assertEquals(0.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 347                         Assert.assertEquals(1.4, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 348                         Assert.assertEquals(5.0, (Double) se.getMin( Bindings.DOUBLE ), 0.01);\r
 349                         Assert.assertEquals(10.0, (Double) se.getMax( Bindings.DOUBLE ), 0.01);\r
 350                         \r
 351                 } finally {\r
 352                         aa.close();\r
 353                 }\r
 354         }\r
 355 \r
 356         \r
 357         @Test\r
 358         public void testDeadband() throws Exception {\r
 359                 // 1. Create history and collector item\r
 360                 SamplingFormat format = allfields.clone();\r
 361                 format.deadband = 2.5;\r
 362                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 363                 historian.create(hi);           \r
 364                 \r
 365                 // 2. Create collector\r
 366                 collector.addItem(hi);          \r
 367                 try {\r
 368                         // Add values, dt=0.1\r
 369                         double[] data = data2;\r
 370                         for (int i=0; i<data.length; i++) \r
 371                         {\r
 372                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 373                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 374                                 collector.endStep();\r
 375                         }                       \r
 376                 } finally {\r
 377                         collector.close();\r
 378                 }\r
 379 \r
 380                 // 3. Verify data\r
 381                 StreamAccessor aa = historian.openStream(hi.id, "r");           \r
 382                 try {\r
 383                         Binding sampleBinding = Bindings.getBinding( format.format );\r
 384                         // Read and assert the sample\r
 385                         Object sample = aa.get(0, sampleBinding);\r
 386                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 387                         Assert.assertEquals(0.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 388                         Assert.assertEquals(0.7, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 389                         Assert.assertEquals(5.0, (Double) se.getValue( Bindings.DOUBLE ), 0.01);\r
 390                         Assert.assertEquals(5.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 391                         Assert.assertEquals(5.0, (Double) se.getMin( Bindings.DOUBLE ), 0.01);\r
 392                         Assert.assertEquals(7.0, (Double) se.getMax( Bindings.DOUBLE ), 0.01);\r
 393                         Assert.assertEquals(8, se.getCount());\r
 394                         \r
 395                         aa.get(1, sampleBinding, sample);\r
 396                         Assert.assertEquals(0.8, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 397                         Assert.assertEquals(1.1, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 398                         Assert.assertEquals(8.0, (Double) se.getValue( Bindings.DOUBLE ), 0.01);\r
 399                         Assert.assertEquals(9.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 400                         Assert.assertEquals(8.0, (Double) se.getMin( Bindings.DOUBLE ), 0.01);\r
 401                         Assert.assertEquals(10.0, (Double) se.getMax( Bindings.DOUBLE ), 0.01);\r
 402                         Assert.assertEquals(4, se.getCount());\r
 403 \r
 404                         aa.get(2, sampleBinding, sample);\r
 405                         Assert.assertEquals(1.2, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 406                         Assert.assertEquals(1.4, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);                      \r
 407                         Assert.assertEquals(5.0, (Double) se.getValue( Bindings.DOUBLE ), 0.01);\r
 408                         Assert.assertEquals(4.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 409                         Assert.assertEquals(3.0, (Double) se.getMin( Bindings.DOUBLE ), 0.01);\r
 410                         Assert.assertEquals(5.0, (Double) se.getMax( Bindings.DOUBLE ), 0.01);\r
 411                         Assert.assertEquals(3, se.getCount());\r
 412                 } finally {\r
 413                         aa.close();\r
 414                 }\r
 415         }\r
 416 \r
 417         \r
 418         @Test\r
 419         public void testMedianAndInterval() throws Exception {\r
 420 \r
 421                 // 1. Create history and collector item\r
 422                 SamplingFormat format = allfields.clone();\r
 423                 format.interval = 1.0;\r
 424                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 425                 historian.create(hi);\r
 426                 // Create binding for the sample format\r
 427                 Binding sampleBinding = Bindings.getBinding( format.format );\r
 428                 \r
 429                 \r
 430                 // 2. Create collector\r
 431                 collector.addItem( hi );\r
 432 \r
 433                 // Write data\r
 434                 try {\r
 435                         // Add values, dt=0.1\r
 436                         double[] data = data2;\r
 437                         for (int i=0; i<data.length; i++) \r
 438                         {\r
 439                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 440                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 441                                 collector.endStep();\r
 442                         }                       \r
 443                 } finally {\r
 444                         collector.close();\r
 445                 }\r
 446                 \r
 447                 // Verify data\r
 448                 StreamAccessor aa = historian.openStream(hi.id, "r");           \r
 449                 try {\r
 450                         // 10s interval. There should be only one entry\r
 451                         Assert.assertEquals(2, aa.size());\r
 452                         \r
 453                         // Read and assert the sample\r
 454                         Object sample = aa.get(0, sampleBinding);\r
 455                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 456                         Assert.assertEquals(0.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 457                         Assert.assertEquals(0.9, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 458                         Assert.assertEquals(6.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 459                         \r
 460                         aa.get(1, sampleBinding, sample);\r
 461                         Assert.assertEquals(1.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 462                         Assert.assertEquals(1.4, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 463                         Assert.assertEquals(5.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 464                         \r
 465                 } finally {\r
 466                         aa.close();\r
 467                 }\r
 468                 \r
 469                 // Reopen subscription\r
 470                 // Write data\r
 471                 collector = new CollectorImpl( historian );                             \r
 472                 try {\r
 473                         // Add values, dt=0.1\r
 474                         double[] data = data2;\r
 475                         for (int i=0; i<data.length; i++) \r
 476                         {\r
 477                                 collector.beginStep(Bindings.DOUBLE, (i+data.length) * 0.1);\r
 478                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 479                                 collector.endStep();\r
 480                         }                       \r
 481                 } finally {\r
 482                         collector.close();\r
 483                 }\r
 484                 \r
 485                 // Verify data\r
 486                 aa = historian.openStream(hi.id, "r");          \r
 487                 try {\r
 488                         Assert.assertEquals(3, aa.size());\r
 489                         \r
 490                         // Read and assert the sample\r
 491                         Object sample = aa.get(0, sampleBinding);\r
 492                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 493                         Assert.assertEquals(0.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 494                         Assert.assertEquals(0.9, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 495                         Assert.assertEquals(6.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 496                         \r
 497                         aa.get(1, sampleBinding, sample);\r
 498                         Assert.assertEquals(1.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 499                         Assert.assertEquals(2.1, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 500                         Assert.assertEquals(5.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 501                         \r
 502                         aa.get(2, sampleBinding, sample);\r
 503                         Assert.assertEquals(2.2, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 504                         Assert.assertEquals(2.9, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 505                         Assert.assertEquals(7.0, (Double) se.getMedian( Bindings.DOUBLE ), 0.01);\r
 506                         \r
 507                 } finally {\r
 508                         aa.close();\r
 509                 }\r
 510                                 \r
 511                 historian.delete(hi.id);\r
 512         }\r
 513 \r
 514         @Test\r
 515         public void testAccessor() throws Exception\r
 516         {\r
 517                 // 1. Create history and collector item\r
 518                 SamplingFormat format = allfields.clone();\r
 519                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 520                 historian.create(hi);\r
 521                 \r
 522                 // 2. Create collector\r
 523                 collector.addItem(hi);\r
 524                 StreamAccessor aa = historian.openStream(hi.id, "r");           \r
 525                 try {\r
 526                         // Write data\r
 527                         double[] data = data2;\r
 528                         for (int i=0; i<data.length; i++) \r
 529                         {\r
 530                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 531                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 532                                 collector.endStep();\r
 533                         }                       \r
 534 \r
 535                         // Assert data\r
 536                         aa.reset();\r
 537                         Assert.assertEquals(10, aa.size());\r
 538                         \r
 539                         // Write some more\r
 540                         for (int i=0; i<data.length; i++) \r
 541                         {\r
 542                                 collector.beginStep(Bindings.DOUBLE, (i + data.length) * 0.1);\r
 543                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 544                                 collector.endStep();\r
 545                         }                       \r
 546                         \r
 547                         // Assert data\r
 548                         aa.reset();\r
 549                         Assert.assertEquals(20, aa.size());\r
 550 \r
 551                         // Print\r
 552                         Binding sampleBinding = Bindings.getBinding( format.format );                   \r
 553                         for (int i=0; i<aa.size(); i++) {\r
 554                                 System.out.println( i+": "+sampleBinding.toString( aa.get(i, sampleBinding) ) );\r
 555                         }\r
 556                         \r
 557                         \r
 558                 } finally {\r
 559                         aa.close();\r
 560                         collector.close();\r
 561                 }\r
 562                 \r
 563         }\r
 564 \r
 565         @Test\r
 566         public void testArrayData() throws Exception\r
 567         {\r
 568                 // 1. Create history and collector item\r
 569                 SamplingFormat format = vector.clone();\r
 570                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 571                 historian.create(hi);\r
 572                 \r
 573                 // 2. Create collector\r
 574                 collector.addItem( hi );\r
 575                 ArrayType vectorType = (ArrayType) ((RecordType)format.format).getComponent("value").type;\r
 576                 Binding vectorBinding = DoubleArrayBinding.createFrom( vectorType );\r
 577                 \r
 578                 // Write data\r
 579                 int count = 20;\r
 580                 try {\r
 581                         // Simulate\r
 582                         double[] vector = new double[] { 1.0, 2.0, 3.0 };\r
 583                         \r
 584                         for (int i=0; i<count; i++) \r
 585                         {\r
 586                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 587                                 \r
 588                                 vector[0] = i;\r
 589                                 vector[1] = i*1.5+1;\r
 590                                 vector[2] = i*-2.4+5;\r
 591                                 \r
 592                                 collector.setValue("MyVariable", vectorBinding, vector);\r
 593                                 collector.endStep();\r
 594                         }\r
 595                         \r
 596                 } finally {\r
 597                         collector.close();\r
 598                 }\r
 599                 \r
 600                 StreamAccessor aa = historian.openStream(hi.id, "r");\r
 601                 try {\r
 602                         Assert.assertEquals(count, aa.size());\r
 603                 } finally {\r
 604                         aa.close();\r
 605                 }\r
 606                 \r
 607                 historian.delete(hi.id);\r
 608         }\r
 609 \r
 610         @Test\r
 611         public void testStringData() throws Exception\r
 612         {\r
 613                 // 1. Create history and collector item\r
 614                 SamplingFormat format = string.clone();\r
 615                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 616                 historian.create(hi);\r
 617                 \r
 618                 // 2. Create collector\r
 619                 collector.addItem( hi );\r
 620                 Binding lineBinding = Bindings.STRING;\r
 621                 \r
 622                 // Write data\r
 623                 int count = 20;\r
 624                 try {\r
 625                         // Simulate\r
 626                         for (int i=0; i<count; i++) \r
 627                         {\r
 628                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 629                                 collector.setValue("MyVariable", lineBinding, "Line: "+i);\r
 630                                 collector.endStep();\r
 631                         }\r
 632                         \r
 633                 } finally {\r
 634                         collector.close();\r
 635                 }\r
 636                 \r
 637                 StreamAccessor aa = historian.openStream(hi.id, "rw");\r
 638                 try {\r
 639                         // Assert data ok\r
 640                         Binding beanBinding = Bindings.getBeanBinding(hi.format);\r
 641                         Assert.assertEquals(count, aa.size());\r
 642                         for (int i=0; i<count; i++) {\r
 643                                 Bean bean = (Bean) aa.get(i, beanBinding);\r
 644                                 String line = (String) bean.getField("value");\r
 645                                 Assert.assertEquals("Line: "+i, line);\r
 646                         }\r
 647                         \r
 648                         // Delete entries\r
 649                         aa.remove(10, 2);\r
 650                         Assert.assertEquals(count-2, aa.size());\r
 651                         for (int i=0; i<10; i++) {\r
 652                                 Bean bean = (Bean) aa.get(i, beanBinding);\r
 653                                 String line = (String) bean.getField("value");\r
 654                                 Assert.assertEquals("Line: "+i, line);\r
 655                         }\r
 656                         for (int i=10; i<18; i++) {\r
 657                                 Bean bean = (Bean) aa.get(i, beanBinding);\r
 658                                 String line = (String) bean.getField("value");\r
 659                                 Assert.assertEquals("Line: "+(i+2), line);\r
 660                         }\r
 661                         \r
 662                 } finally {\r
 663                         aa.close();\r
 664                 }\r
 665                 \r
 666                 historian.delete(hi.id);\r
 667         }\r
 668         \r
 669 \r
 670         @Test\r
 671         public void testMinMax() throws Exception {\r
 672                 // 1. Create history and collector item\r
 673                 SamplingFormat format = minmax.clone();\r
 674                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 675                 historian.create(hi);\r
 676                 \r
 677                 // 2. Create collector\r
 678                 collector.addItem( hi );\r
 679 \r
 680                 // 3. Write data\r
 681                 try {\r
 682                         // Add values, dt=0.1\r
 683                         double[] data = data1;\r
 684                         for (int i=0; i<data.length; i++) \r
 685                         {\r
 686                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 687                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 688                                 collector.endStep();\r
 689                         }                       \r
 690                 } finally {\r
 691                         collector.close();\r
 692                 }\r
 693 \r
 694                 // 3. Verify data\r
 695                 StreamAccessor aa = historian.openStream(hi.id, "r");\r
 696                 try {\r
 697                         Assert.assertEquals(1, aa.size());\r
 698                         Binding sampleBinding = Bindings.getBinding( format.format );\r
 699                         // Read and assert the sample\r
 700                         Object sample = aa.get(0, sampleBinding);\r
 701                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 702                         Assert.assertEquals(0.0, (Double) se.getTime( Bindings.DOUBLE ), 0.01);\r
 703                         Assert.assertEquals(1.4, (Double) se.getEndTime( Bindings.DOUBLE ), 0.01);\r
 704                         Assert.assertEquals(5.0, (Double) se.getMin( Bindings.DOUBLE ), 0.01);\r
 705                         Assert.assertEquals(10.0, (Double) se.getMax( Bindings.DOUBLE ), 0.01);\r
 706                 } finally {\r
 707                         aa.close();\r
 708                 }\r
 709                 \r
 710         }\r
 711         \r
 712         \r
 713         public @Test void testStream() throws Exception {\r
 714                 // 1. Create history and collector item\r
 715                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", SamplingFormat.allfields);\r
 716                 historian.create(hi);\r
 717                 \r
 718                 // 2. Create collector\r
 719                 collector.addItem( hi );\r
 720 \r
 721                 // 3. Write and assert data\r
 722                 StreamAccessor aa = historian.openStream(hi.id, "r");\r
 723                 try {\r
 724                         // Write data\r
 725                         double[] data = data2;\r
 726                         for (int i=0; i<data.length; i++) \r
 727                         {\r
 728                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 729                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 730                                 collector.endStep();\r
 731                         }                       \r
 732                         \r
 733                         // Assert data\r
 734                         aa.reset();\r
 735                         Stream stream = new Stream(aa);\r
 736                         \r
 737                         Object sample0 = aa.get(0, stream.sampleBinding);\r
 738                         Object sample1 = aa.get(1, stream.sampleBinding);\r
 739                         Object sample;\r
 740                         \r
 741                         sample = stream.getLowerSample(Bindings.DOUBLE, 0.0);\r
 742                         Assert.assertNull(sample);\r
 743                         \r
 744                         sample = stream.getLowerSample(Bindings.DOUBLE, 0.05);\r
 745                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 746 \r
 747                         sample = stream.getFloorSample(Bindings.DOUBLE, 0.05);\r
 748                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 749 \r
 750                         sample = stream.getFloorSample(Bindings.DOUBLE, 0.00);\r
 751                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 752                         \r
 753                         sample = stream.getSample(Bindings.DOUBLE, 0.05);\r
 754                         Assert.assertNull(sample);\r
 755 \r
 756                         sample = stream.getSample(Bindings.DOUBLE, 0.00);\r
 757                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 758 \r
 759                         sample = stream.getCeilingSample(Bindings.DOUBLE, -0.10);\r
 760                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 761                         \r
 762                         sample = stream.getCeilingSample(Bindings.DOUBLE, 0.00);\r
 763                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 764 \r
 765                         sample = stream.getCeilingSample(Bindings.DOUBLE, 0.05);\r
 766                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample1) );\r
 767 \r
 768                         sample = stream.getHigherSample(Bindings.DOUBLE, -0.05);\r
 769                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );\r
 770 \r
 771                         sample = stream.getHigherSample(Bindings.DOUBLE, 0.00);\r
 772                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample1) );\r
 773                         \r
 774                         sample = stream.getHigherSample(Bindings.DOUBLE, 0.05);\r
 775                         Assert.assertTrue( stream.sampleBinding.equals(sample, sample1) );\r
 776                         \r
 777                         sample = stream.getHigherSample(Bindings.DOUBLE, 1.45);\r
 778                         Assert.assertNull( sample );\r
 779                 } finally {\r
 780                         aa.close();\r
 781                         collector.close();\r
 782                 }\r
 783         }\r
 784         \r
 785 \r
 786         @Test\r
 787         public void testByteData() throws Exception {\r
 788                 // 1. Create stream\r
 789                 SamplingFormat format = byteformat.clone();\r
 790                 format.formatId = "test";\r
 791                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 792                 historian.create( hi );\r
 793                 \r
 794                 // 2. Create collector\r
 795                 collector.addItem(hi);\r
 796 \r
 797                 // 3. Write and assert data\r
 798                 try {\r
 799                         // Write data\r
 800                         double[] data = data2;\r
 801                         for (int i=0; i<data.length; i++) \r
 802                         {\r
 803                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 804                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 805                                 collector.endStep();\r
 806                         }                       \r
 807         \r
 808                         // Verify data\r
 809                         StreamAccessor aa = historian.openStream(hi.id, "r");                           \r
 810                         try {\r
 811                                 Assert.assertEquals(data3.length, aa.size());\r
 812                                 Binding sampleBinding = Bindings.getBinding( format.format );\r
 813                                 // Read and assert the sample\r
 814                                 Object sample = aa.get(0, sampleBinding);\r
 815                                 ValueBand se = new ValueBand( sampleBinding, sample );\r
 816                                 for (int i=0; i<data3.length; i++) {\r
 817                                         aa.get(i, sampleBinding, se.getSample());\r
 818                                         Assert.assertEquals(data3[i], se.getValue(Bindings.BYTE));\r
 819                                 }\r
 820                         } finally {\r
 821                                 aa.close();\r
 822                         }                       \r
 823                         \r
 824                 } finally {\r
 825                         collector.close();\r
 826                 }\r
 827                 \r
 828         }\r
 829         \r
 830         @Test\r
 831         public void testCSVData() throws Exception {\r
 832                 SamplingFormat format = simple.clone();\r
 833                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format );\r
 834                 historian.create( hi );\r
 835                 collector.addItem( hi );\r
 836                 try {\r
 837                         // Write data\r
 838                         double[] data = data1;\r
 839                         for (int i=0; i<data.length; i++) \r
 840                         {\r
 841                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 842                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 843                                 collector.endStep();\r
 844                         }                       \r
 845                 } finally {\r
 846                         collector.close();\r
 847                 }\r
 848                 \r
 849                 CSVFormatter csv = new CSVFormatter();\r
 850                 csv.addItem(historian, hi.id, "MyVariable", "MyVariable", "m");\r
 851                 csv.setTimeRange(0.9, 1.5);\r
 852                 csv.setTimeStep(0.1);\r
 853                 StringBuilder sb = new StringBuilder();\r
 854 //              csv.formulate1(new ProgressMonitor.Stub(), sb);\r
 855 //              sb.append("\n----\n");\r
 856                 csv.formulate2(new ProgressMonitor.Stub(), sb);\r
 857                 System.out.println(sb);\r
 858                 \r
 859         }\r
 860         \r
 861         @Test\r
 862         public void testExport() throws Exception {\r
 863                 SamplingFormat format = byteformat.clone();\r
 864                 \r
 865                 // 2. Write data\r
 866                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", byteformat );\r
 867                 historian.create( hi );\r
 868                 collector.addItem( hi );\r
 869                 try {\r
 870                         // Write data\r
 871                         double[] data = data2;\r
 872                         for (int i=0; i<data.length; i++) \r
 873                         {\r
 874                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 875                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 876                                 collector.endStep();\r
 877                         }                       \r
 878                 } finally {\r
 879                         collector.close();\r
 880                 }\r
 881                 \r
 882                 // Export data\r
 883                 ByteArrayOutputStream os = new ByteArrayOutputStream(1024);\r
 884                 History.exportHistory(historian, Bindings.DOUBLE, -Double.MAX_VALUE, Double.MAX_VALUE, os);\r
 885         \r
 886                 // Create another historian\r
 887                 HistoryManager historian2 = History.createMemoryHistory();\r
 888                 ByteArrayInputStream is = new ByteArrayInputStream( os.toByteArray() );\r
 889                 History.importHistory(historian2, is);\r
 890                 \r
 891                 // Verify data\r
 892                 StreamAccessor aa = historian2.openStream(hi.id, "r");                          \r
 893                 try {\r
 894                         Assert.assertEquals(data3.length, aa.size());\r
 895                         Binding sampleBinding = Bindings.getBinding( format.format );\r
 896                         // Read and assert the sample\r
 897                         Object sample = aa.get(0, sampleBinding);\r
 898                         ValueBand se = new ValueBand( sampleBinding, sample );\r
 899                         for (int i=0; i<data3.length; i++) {\r
 900                                 aa.get(i, sampleBinding, se.getSample());\r
 901                                 Assert.assertEquals(data3[i], se.getValue(Bindings.BYTE));\r
 902                         }\r
 903                 } finally {\r
 904                         aa.close();\r
 905                 }                       \r
 906         }\r
 907         \r
 908         \r
 909         @Test\r
 910         public void testStreamIterator() throws Exception {\r
 911                 // 1. Create history and collector item\r
 912                 SamplingFormat format = allfields.clone();\r
 913                 format.deadband = 0.05;\r
 914                 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", format);\r
 915                 historian.create(hi);           \r
 916                 \r
 917                 // 2. Create collector\r
 918                 collector.addItem(hi);          \r
 919                 try {\r
 920                         // Add values, dt=0.1\r
 921                         double[] data = data1;\r
 922                         for (int i=0; i<data.length; i++) \r
 923                         {\r
 924                                 collector.beginStep(Bindings.DOUBLE, i * 0.1);\r
 925                                 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);\r
 926                                 collector.endStep();\r
 927                         }                       \r
 928                 } finally {\r
 929                         collector.close();\r
 930                 }\r
 931 \r
 932                 // 3. Verify data\r
 933                 StreamAccessor aa = historian.openStream(hi.id, "r");           \r
 934                 try {\r
 935                         StreamIterator si = new StreamIterator( aa );\r
 936                         while (si.hasNext()) {\r
 937                                 si.next();\r
 938                                 System.out.println( si );\r
 939                         }\r
 940                         \r
 941                         si.gotoTime( -1 );\r
 942                         System.out.println( si );\r
 943                         \r
 944                         si.gotoTime( 0.55 );\r
 945                         System.out.println( si );\r
 946                         \r
 947                         si.proceedToTime( 0.6 );\r
 948                         System.out.println( si );\r
 949                         \r
 950                         si.proceedToTime( 1.11 );\r
 951                         System.out.println( si );\r
 952 \r
 953                         si.gotoTime( 1.4 );\r
 954                         System.out.println( si );\r
 955                         \r
 956                         si.gotoTime( 1.5 );\r
 957                         System.out.println( si );\r
 958                         \r
 959                         \r
 960                 } finally {\r
 961                         aa.close();\r
 962                 }\r
 963         }\r
 964         \r
 965 }\r