1 /*******************************************************************************
\r
2 * Copyright (c) 2007, 2011 Association for Decentralized Information Management in
\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
10 * VTT Technical Research Centre of Finland - initial API and implementation
\r
11 *******************************************************************************/
\r
12 package org.simantics.history.test;
\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
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
49 public class TestHistory {
\r
51 static final double NaN = Double.NaN;
\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
58 // Subscription formats
\r
59 SamplingFormat simple, allfields, vector, minmax, byteformat, string;
\r
62 HistoryManager historian;
\r
64 Collector collector;
\r
67 public void initSubscriptionFormats()
\r
69 simple = new SamplingFormat();
\r
70 simple.formatId = "simple";
\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
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
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
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
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
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
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
158 public void uninitHistory() {
\r
159 if ( collector != null ) {
\r
160 collector.close();
\r
162 if ( historian != null ) {
\r
165 if ( workarea != null) {
\r
167 FileUtils.deleteAll(workarea);
\r
168 } catch (IOException e) {
\r
169 e.printStackTrace();
\r
175 public void testGetModifySubscription() throws Exception
\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
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
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
198 collector.removeItem(hi.id);
\r
199 Assert.assertEquals(0, collector.getItems().length);
\r
200 collector.addItem(hi);
\r
202 // 5. Open & Modify subscription
\r
203 collector.beginStep(Bindings.DOUBLE, 5.0);
\r
205 collector.setItem(hi);
\r
206 collector.endStep();
\r
209 // 6. Read from history
\r
210 Bean bean = historian.getItem(hi.id);
\r
212 hi.readAvailableFields(bean);
\r
213 Assert.assertEquals(1.2, hi.interval, 0.1);
\r
217 public void failtestRecreateSubscription() throws HistoryException
\r
219 Collector collector2;
\r
220 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", allfields);
\r
221 historian.create(hi);
\r
223 collector.addItem( hi );
\r
224 collector2 = new CollectorImpl( historian );
\r
225 collector2.addItem( hi );
\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
235 collector2.close();
\r
239 public void failtestReopenStream() throws HistoryException
\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
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
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
261 historian.delete( his[0].id, his[1].id );
\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
272 // 2. Create collector
\r
273 collector.addItems(hi);
\r
278 double[] data = data1;
\r
279 for (int i=0; i<4; i++)
\r
281 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
282 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
283 collector.endStep();
\r
287 hi[0].enabled = false;
\r
288 collector.setItem(hi[0]);
\r
289 for (int i=4; i<12; i++)
\r
291 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
292 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
293 collector.endStep();
\r
297 hi[0].enabled = true;
\r
298 collector.setItem(hi[0]);
\r
299 for (int i=12; i<data.length; i++)
\r
301 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
302 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
303 collector.endStep();
\r
312 StreamAccessor aa = historian.openStream(hi[0].id, "r");
\r
314 Binding sampleBinding = Bindings.getBinding( allfields.format );
\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
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
329 aa.get(2, sampleBinding, sample);
\r
330 Assert.assertEquals(1.2, (Double) se.getTime( Bindings.DOUBLE ), 0.01);
\r
337 // 4. Verify min-max has only 1 sample
\r
338 aa = historian.openStream(hi[1].id, "r");
\r
340 Assert.assertEquals(1, aa.size());
\r
341 Binding sampleBinding = Bindings.getBinding( minmax.format );
\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
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
365 // 2. Create collector
\r
366 collector.addItem(hi);
\r
368 // Add values, dt=0.1
\r
369 double[] data = data2;
\r
370 for (int i=0; i<data.length; i++)
\r
372 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
373 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
374 collector.endStep();
\r
381 StreamAccessor aa = historian.openStream(hi.id, "r");
\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
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
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
419 public void testMedianAndInterval() throws Exception {
\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
430 // 2. Create collector
\r
431 collector.addItem( hi );
\r
435 // Add values, dt=0.1
\r
436 double[] data = data2;
\r
437 for (int i=0; i<data.length; i++)
\r
439 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
440 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
441 collector.endStep();
\r
448 StreamAccessor aa = historian.openStream(hi.id, "r");
\r
450 // 10s interval. There should be only one entry
\r
451 Assert.assertEquals(2, aa.size());
\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
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
469 // Reopen subscription
\r
471 collector = new CollectorImpl( historian );
\r
473 // Add values, dt=0.1
\r
474 double[] data = data2;
\r
475 for (int i=0; i<data.length; i++)
\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
486 aa = historian.openStream(hi.id, "r");
\r
488 Assert.assertEquals(3, aa.size());
\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
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
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
511 historian.delete(hi.id);
\r
515 public void testAccessor() throws Exception
\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
522 // 2. Create collector
\r
523 collector.addItem(hi);
\r
524 StreamAccessor aa = historian.openStream(hi.id, "r");
\r
527 double[] data = data2;
\r
528 for (int i=0; i<data.length; i++)
\r
530 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
531 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
532 collector.endStep();
\r
537 Assert.assertEquals(10, aa.size());
\r
540 for (int i=0; i<data.length; i++)
\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
549 Assert.assertEquals(20, aa.size());
\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
566 public void testArrayData() throws Exception
\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
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
582 double[] vector = new double[] { 1.0, 2.0, 3.0 };
\r
584 for (int i=0; i<count; i++)
\r
586 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
589 vector[1] = i*1.5+1;
\r
590 vector[2] = i*-2.4+5;
\r
592 collector.setValue("MyVariable", vectorBinding, vector);
\r
593 collector.endStep();
\r
600 StreamAccessor aa = historian.openStream(hi.id, "r");
\r
602 Assert.assertEquals(count, aa.size());
\r
607 historian.delete(hi.id);
\r
611 public void testStringData() throws Exception
\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
618 // 2. Create collector
\r
619 collector.addItem( hi );
\r
620 Binding lineBinding = Bindings.STRING;
\r
626 for (int i=0; i<count; i++)
\r
628 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
629 collector.setValue("MyVariable", lineBinding, "Line: "+i);
\r
630 collector.endStep();
\r
637 StreamAccessor aa = historian.openStream(hi.id, "rw");
\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
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
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
666 historian.delete(hi.id);
\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
677 // 2. Create collector
\r
678 collector.addItem( hi );
\r
682 // Add values, dt=0.1
\r
683 double[] data = data1;
\r
684 for (int i=0; i<data.length; i++)
\r
686 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
687 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
688 collector.endStep();
\r
695 StreamAccessor aa = historian.openStream(hi.id, "r");
\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
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
718 // 2. Create collector
\r
719 collector.addItem( hi );
\r
721 // 3. Write and assert data
\r
722 StreamAccessor aa = historian.openStream(hi.id, "r");
\r
725 double[] data = data2;
\r
726 for (int i=0; i<data.length; i++)
\r
728 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
729 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
730 collector.endStep();
\r
735 Stream stream = new Stream(aa);
\r
737 Object sample0 = aa.get(0, stream.sampleBinding);
\r
738 Object sample1 = aa.get(1, stream.sampleBinding);
\r
741 sample = stream.getLowerSample(Bindings.DOUBLE, 0.0);
\r
742 Assert.assertNull(sample);
\r
744 sample = stream.getLowerSample(Bindings.DOUBLE, 0.05);
\r
745 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
747 sample = stream.getFloorSample(Bindings.DOUBLE, 0.05);
\r
748 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
750 sample = stream.getFloorSample(Bindings.DOUBLE, 0.00);
\r
751 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
753 sample = stream.getSample(Bindings.DOUBLE, 0.05);
\r
754 Assert.assertNull(sample);
\r
756 sample = stream.getSample(Bindings.DOUBLE, 0.00);
\r
757 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
759 sample = stream.getCeilingSample(Bindings.DOUBLE, -0.10);
\r
760 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
762 sample = stream.getCeilingSample(Bindings.DOUBLE, 0.00);
\r
763 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
765 sample = stream.getCeilingSample(Bindings.DOUBLE, 0.05);
\r
766 Assert.assertTrue( stream.sampleBinding.equals(sample, sample1) );
\r
768 sample = stream.getHigherSample(Bindings.DOUBLE, -0.05);
\r
769 Assert.assertTrue( stream.sampleBinding.equals(sample, sample0) );
\r
771 sample = stream.getHigherSample(Bindings.DOUBLE, 0.00);
\r
772 Assert.assertTrue( stream.sampleBinding.equals(sample, sample1) );
\r
774 sample = stream.getHigherSample(Bindings.DOUBLE, 0.05);
\r
775 Assert.assertTrue( stream.sampleBinding.equals(sample, sample1) );
\r
777 sample = stream.getHigherSample(Bindings.DOUBLE, 1.45);
\r
778 Assert.assertNull( sample );
\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
794 // 2. Create collector
\r
795 collector.addItem(hi);
\r
797 // 3. Write and assert data
\r
800 double[] data = data2;
\r
801 for (int i=0; i<data.length; i++)
\r
803 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
804 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
805 collector.endStep();
\r
809 StreamAccessor aa = historian.openStream(hi.id, "r");
\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
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
838 double[] data = data1;
\r
839 for (int i=0; i<data.length; i++)
\r
841 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
842 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
843 collector.endStep();
\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
862 public void testExport() throws Exception {
\r
863 SamplingFormat format = byteformat.clone();
\r
866 SubscriptionItem hi = SubscriptionItem.createItem("MyVariable", "MySubscription", byteformat );
\r
867 historian.create( hi );
\r
868 collector.addItem( hi );
\r
871 double[] data = data2;
\r
872 for (int i=0; i<data.length; i++)
\r
874 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
875 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
876 collector.endStep();
\r
883 ByteArrayOutputStream os = new ByteArrayOutputStream(1024);
\r
884 History.exportHistory(historian, Bindings.DOUBLE, -Double.MAX_VALUE, Double.MAX_VALUE, os);
\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
892 StreamAccessor aa = historian2.openStream(hi.id, "r");
\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
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
917 // 2. Create collector
\r
918 collector.addItem(hi);
\r
920 // Add values, dt=0.1
\r
921 double[] data = data1;
\r
922 for (int i=0; i<data.length; i++)
\r
924 collector.beginStep(Bindings.DOUBLE, i * 0.1);
\r
925 collector.setValue("MyVariable", Bindings.DOUBLE, data[i]);
\r
926 collector.endStep();
\r
933 StreamAccessor aa = historian.openStream(hi.id, "r");
\r
935 StreamIterator si = new StreamIterator( aa );
\r
936 while (si.hasNext()) {
\r
938 System.out.println( si );
\r
942 System.out.println( si );
\r
944 si.gotoTime( 0.55 );
\r
945 System.out.println( si );
\r
947 si.proceedToTime( 0.6 );
\r
948 System.out.println( si );
\r
950 si.proceedToTime( 1.11 );
\r
951 System.out.println( si );
\r
953 si.gotoTime( 1.4 );
\r
954 System.out.println( si );
\r
956 si.gotoTime( 1.5 );
\r
957 System.out.println( si );
\r