Skip to content

Commit 24004b5

Browse files
shroffkshroffk
committed
adding unit tests for SimpleValueFormat
1 parent ef30934 commit 24004b5

1 file changed

Lines changed: 213 additions & 0 deletions

File tree

‎epics-vtype/vtype/src/test/java/org/epics/vtype/SimpleValueFormatTest.java‎

Lines changed: 213 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,213 @@
1+
/**
2+
* Copyright (C) 2010-18 epics and diirt developers. See COPYRIGHT.TXT
3+
* All rights reserved. Use is subject to license terms. See LICENSE.TXT
4+
*/
5+
package org.epics.vtype;
6+
7+
import static org.hamcrest.CoreMatchers.equalTo;
8+
import static org.junit.Assert.assertThat;
9+
10+
import java.util.Arrays;
11+
import java.util.List;
12+
13+
import org.epics.util.array.ArrayByte;
14+
import org.epics.util.array.ArrayDouble;
15+
import org.epics.util.array.ArrayFloat;
16+
import org.epics.util.array.ArrayInteger;
17+
import org.epics.util.array.ArrayShort;
18+
import org.epics.util.array.ListByte;
19+
import org.epics.util.array.ListDouble;
20+
import org.epics.util.array.ListFloat;
21+
import org.epics.util.stats.Range;
22+
import org.epics.util.text.NumberFormats;
23+
import org.junit.Test;
24+
import org.mockito.Mockito;
25+
26+
/**
27+
*
28+
* @author carcassi
29+
*/
30+
public class SimpleValueFormatTest {
31+
Range maxDoubleRange = Range.of(Double.MIN_VALUE, Double.MAX_VALUE);
32+
Display display = Display.of(maxDoubleRange, maxDoubleRange, maxDoubleRange, maxDoubleRange, "",
33+
NumberFormats.precisionFormat(3));
34+
35+
Display displayInt = Display.of(maxDoubleRange, maxDoubleRange, maxDoubleRange, maxDoubleRange, "",
36+
NumberFormats.precisionFormat(0));
37+
38+
@Test
39+
public void defaultPrecision() {
40+
ValueFormat f = new SimpleValueFormat(3);
41+
assertThat(f.format(VDouble.of(1234.5678, Alarm.none(), Time.now(), display)), equalTo("1234.568"));
42+
assertThat(f.format(VIntArray.of(ArrayInteger.of(1, 2, 3), Alarm.none(), Time.now(), displayInt)), equalTo("[1, 2, 3]"));
43+
assertThat(f.format(VIntArray.of(ArrayInteger.of(1), Alarm.none(), Time.now(), displayInt)), equalTo("[1]"));
44+
assertThat(f.format(VIntArray.of(ArrayInteger.of(1, 2, 3, 4, 5), Alarm.none(), Time.now(), displayInt)), equalTo("[1, 2, 3, ...]"));
45+
assertThat(f.format(VFloatArray.of(ArrayFloat.of(new float[] {1, 2, 3}), Alarm.none(), Time.now(), display)), equalTo("[1.000, 2.000, 3.000]"));
46+
assertThat(f.format(VFloatArray.of(ArrayFloat.of(new float[] {1}), Alarm.none(), Time.now(), display)), equalTo("[1.000]"));
47+
assertThat(f.format(VFloatArray.of(ArrayFloat.of(new float[] {1, 2, 3, 4, 5}), Alarm.none(), Time.now(), display)), equalTo("[1.000, 2.000, 3.000, ...]"));
48+
assertThat(f.format(VDoubleArray.of(ArrayDouble.of(1, 2, 3), Alarm.none(), Time.now(), display)), equalTo("[1.000, 2.000, 3.000]"));
49+
assertThat(f.format(VDoubleArray.of(ArrayDouble.of(1), Alarm.none(), Time.now(), display)), equalTo("[1.000]"));
50+
assertThat(f.format(VDoubleArray.of(ArrayDouble.of(1, 2, 3, 4, 5), Alarm.none(), Time.now(), display)), equalTo("[1.000, 2.000, 3.000, ...]"));
51+
assertThat(f.format(VStringArray.of(Arrays.asList("A", "B", "C"), Alarm.none(), Time.now())), equalTo("[A, B, C]"));
52+
assertThat(f.format(VStringArray.of(Arrays.asList("A"), Alarm.none(), Time.now())), equalTo("[A]"));
53+
assertThat(f.format(VStringArray.of(Arrays.asList("A", "B", "C", "D", "E"), Alarm.none(), Time.now())), equalTo("[A, B, C, ...]"));
54+
// assertThat(f.format(newVEnumArray(ArrayInteger.of(2, 0, 0), Arrays.asList("A", "B", "C"), Alarm.none(), Time.now())), equalTo("[C, A, A]"));
55+
// assertThat(f.format(newVEnumArray(ArrayInteger.of(2), Arrays.asList("A", "B", "C"), Alarm.none(), Time.now())), equalTo("[C]"));
56+
// assertThat(f.format(newVEnumArray(ArrayInteger.of(2, 0, 0, 1, 0), Arrays.asList("A", "B", "C"), Alarm.none(), Time.now())), equalTo("[C, A, A, ...]"));
57+
}
58+
59+
@Test
60+
public void testMandatedPrecision() {
61+
ValueFormat f = new SimpleValueFormat(3);
62+
f.setNumberFormat(NumberFormats.precisionFormat(2));
63+
assertThat(f.format(VDouble.of(1234.5678, Alarm.none(), Time.now(), display)), equalTo("1234.57"));
64+
assertThat(f.format(VIntArray.of(ArrayInteger.of(1, 2, 3), Alarm.none(), Time.now(), displayInt)), equalTo("[1.00, 2.00, 3.00]"));
65+
assertThat(f.format(VIntArray.of(ArrayInteger.of(1), Alarm.none(), Time.now(), displayInt)), equalTo("[1.00]"));
66+
assertThat(f.format(VIntArray.of(ArrayInteger.of(1, 2, 3, 4, 5), Alarm.none(), Time.now(), displayInt)), equalTo("[1.00, 2.00, 3.00, ...]"));
67+
assertThat(f.format(VFloatArray.of(ArrayFloat.of(new float[] {1, 2, 3}), Alarm.none(), Time.now(), display)), equalTo("[1.00, 2.00, 3.00]"));
68+
assertThat(f.format(VFloatArray.of(ArrayFloat.of(new float[] {1}), Alarm.none(), Time.now(), display)), equalTo("[1.00]"));
69+
assertThat(f.format(VFloatArray.of(ArrayFloat.of(new float[] {1, 2, 3, 4, 5}), Alarm.none(), Time.now(), display)), equalTo("[1.00, 2.00, 3.00, ...]"));
70+
assertThat(f.format(VDoubleArray.of(ArrayDouble.of(1, 2, 3), Alarm.none(), Time.now(), display)), equalTo("[1.00, 2.00, 3.00]"));
71+
assertThat(f.format(VDoubleArray.of(ArrayDouble.of(1), Alarm.none(), Time.now(), display)), equalTo("[1.00]"));
72+
assertThat(f.format(VDoubleArray.of(ArrayDouble.of(1, 2, 3, 4, 5), Alarm.none(), Time.now(), display)), equalTo("[1.00, 2.00, 3.00, ...]"));
73+
assertThat(f.format(VStringArray.of(Arrays.asList("A", "B", "C"), Alarm.none(), Time.now())), equalTo("[A, B, C]"));
74+
assertThat(f.format(VStringArray.of(Arrays.asList("A"), Alarm.none(), Time.now())), equalTo("[A]"));
75+
assertThat(f.format(VStringArray.of(Arrays.asList("A", "B", "C", "D", "E"), Alarm.none(), Time.now())), equalTo("[A, B, C, ...]"));
76+
}
77+
78+
@Test
79+
public void parseVDouble1() {
80+
ValueFormat f = new SimpleValueFormat(3);
81+
VDouble reference = VDouble.of(3.0, Alarm.none(), Time.now(), Display.none());
82+
assertThat(f.parseObject("3.14", reference), equalTo((Object) 3.14));
83+
assertThat(f.parseDouble("3.14"), equalTo(3.14));
84+
assertThat(f.parseDouble("1333"), equalTo(1333.0));
85+
}
86+
87+
@Test
88+
public void parseVFloat1() {
89+
ValueFormat f = new SimpleValueFormat(3);
90+
VFloat reference = Mockito.mock(VFloat.class);
91+
assertThat(f.parseObject("3.14", reference), equalTo((Object) 3.14f));
92+
assertThat(f.parseFloat("3.14"), equalTo(3.14f));
93+
assertThat(f.parseFloat("1333"), equalTo(1333.0f));
94+
}
95+
96+
@Test
97+
public void parseVInt1() {
98+
ValueFormat f = new SimpleValueFormat(3);
99+
VInt reference = Mockito.mock(VInt.class);
100+
assertThat(f.parseObject("314", reference), equalTo((Object) 314));
101+
assertThat(f.parseInt("314"), equalTo(314));
102+
assertThat(f.parseInt("1333"), equalTo(1333));
103+
}
104+
105+
@Test
106+
public void parseVShort1() {
107+
ValueFormat f = new SimpleValueFormat(3);
108+
VShort reference = Mockito.mock(VShort.class);
109+
assertThat(f.parseObject("314", reference), equalTo((Object) (short) 314));
110+
assertThat(f.parseShort("314"), equalTo((short) 314));
111+
assertThat(f.parseShort("1333"), equalTo((short) 1333));
112+
}
113+
114+
@Test
115+
public void parseVByte1() {
116+
ValueFormat f = new SimpleValueFormat(3);
117+
VByte reference = Mockito.mock(VByte.class);
118+
assertThat(f.parseObject("23", reference), equalTo((Object) (byte) 23));
119+
assertThat(f.parseByte("23"), equalTo((byte) 23));
120+
assertThat(f.parseByte("112"), equalTo((byte) 112));
121+
}
122+
123+
@Test
124+
public void parseVString1() {
125+
ValueFormat f = new SimpleValueFormat(3);
126+
VString reference = Mockito.mock(VString.class);
127+
assertThat(f.parseObject("Testing", reference), equalTo((Object) "Testing"));
128+
assertThat(f.parseString("Testing"), equalTo("Testing"));
129+
assertThat(f.parseString("Foo"), equalTo("Foo"));
130+
}
131+
132+
@Test
133+
public void parseVEnum1() {
134+
ValueFormat f = new SimpleValueFormat(3);
135+
List<String> labels = Arrays.asList("A", "B", "C");
136+
VEnum reference = VEnum.of(0, EnumDisplay.of(labels), Alarm.none(), Time.now());
137+
assertThat(f.parseObject("A", reference), equalTo((Object) 0));
138+
assertThat(f.parseEnum("A", labels), equalTo(0));
139+
assertThat(f.parseEnum("B", labels), equalTo(1));
140+
}
141+
142+
@Test
143+
public void parseVDoubleArray1() {
144+
ValueFormat f = new SimpleValueFormat(3);
145+
VDoubleArray reference = Mockito.mock(VDoubleArray.class);
146+
assertThat(f.parseObject("3.14", reference), equalTo((Object) ArrayDouble.of(3.14)));
147+
assertThat(f.parseDoubleArray("3.14"), equalTo((ListDouble) ArrayDouble.of(3.14)));
148+
assertThat(f.parseDoubleArray("1333, 3.14"), equalTo((ListDouble) ArrayDouble.of(1333, 3.14)));
149+
assertThat(f.parseDoubleArray("1.0, 2.0, 3.0, 4.0"), equalTo((ListDouble) ArrayDouble.of(1.0, 2.0, 3.0, 4.0)));
150+
}
151+
152+
@Test
153+
public void parseVFloatArray1() {
154+
ValueFormat f = new SimpleValueFormat(3);
155+
VFloatArray reference = Mockito.mock(VFloatArray.class);
156+
assertThat(f.parseObject("3.14", reference), equalTo((Object) ArrayFloat.of(3.14f)));
157+
assertThat(f.parseFloatArray("3.14"), equalTo((ListFloat) ArrayFloat.of(3.14f)));
158+
assertThat(f.parseFloatArray("1333, 3.14"), equalTo((ListFloat) ArrayFloat.of(1333f, 3.14f)));
159+
assertThat(f.parseFloatArray("1.0, 2.0, 3.0, 4.0"), equalTo((ListFloat) ArrayFloat.of(1.0f, 2.0f, 3.0f, 4.0f)));
160+
}
161+
162+
@Test
163+
public void parseVIntArray1() {
164+
ValueFormat f = new SimpleValueFormat(3);
165+
VIntArray reference = Mockito.mock(VIntArray.class);
166+
assertThat(f.parseObject("3", reference), equalTo((Object) ArrayInteger.of(3)));
167+
assertThat(f.parseIntArray("3"), equalTo(ArrayInteger.of(3)));
168+
assertThat(f.parseIntArray("1333, 3"), equalTo(ArrayInteger.of(1333, 3)));
169+
assertThat(f.parseIntArray("1, 2, 3, 4"), equalTo(ArrayInteger.of(1, 2, 3, 4)));
170+
}
171+
172+
@Test
173+
public void parseVShortArray1() {
174+
ValueFormat f = new SimpleValueFormat(3);
175+
VShortArray reference = Mockito.mock(VShortArray.class);
176+
assertThat(f.parseObject("3", reference), equalTo((Object) ArrayShort.of((short) 3)));
177+
assertThat(f.parseShortArray("3"), equalTo(ArrayShort.of((short) 3)));
178+
assertThat(f.parseShortArray("1333, 3"), equalTo(ArrayShort.of(new short[]{1333, 3})));
179+
assertThat(f.parseShortArray("1, 2, 3, 4"), equalTo(ArrayShort.of(new short[]{1, 2, 3, 4})));
180+
}
181+
182+
@Test
183+
public void parseVByteArray1() {
184+
ValueFormat f = new SimpleValueFormat(3);
185+
VByteArray reference = Mockito.mock(VByteArray.class);
186+
assertThat(f.parseObject("3", reference), equalTo((Object) ArrayByte.of(new byte[] {3})));
187+
assertThat(f.parseByteArray("3"), equalTo((ListByte) ArrayByte.of(new byte[] {3})));
188+
assertThat(f.parseByteArray("113, 3"), equalTo((ListByte) ArrayByte.of(new byte[] {113, 3})));
189+
assertThat(f.parseByteArray("1, 2, 3, 4"), equalTo((ListByte) ArrayByte.of(new byte[] {1, 2, 3, 4})));
190+
}
191+
192+
@Test
193+
public void parseVStringArray1() {
194+
ValueFormat f = new SimpleValueFormat(3);
195+
VStringArray reference = Mockito.mock(VStringArray.class);
196+
assertThat(f.parseObject("test", reference), equalTo((Object) Arrays.asList("test")));
197+
assertThat(f.parseStringArray("test"), equalTo(Arrays.asList("test")));
198+
assertThat(f.parseStringArray("a, b"), equalTo(Arrays.asList("a", "b")));
199+
assertThat(f.parseStringArray("a, b, c, d"), equalTo(Arrays.asList("a", "b", "c", "d")));
200+
}
201+
202+
// @Test
203+
// public void parseVEnumArray1() {
204+
// ValueFormat f = new SimpleValueFormat(3);
205+
// List<String> labels = Arrays.asList("A", "B", "C");
206+
// VEnumArray reference = newVEnumArray(ArrayInteger.of(1), labels, Alarm.none(), Time.now());
207+
// assertThat(f.parseObject("A", reference), equalTo((Object) ArrayInteger.of(0)));
208+
// assertThat(f.parseEnumArray("A", labels), equalTo((ListInt) ArrayInteger.of(0)));
209+
// assertThat(f.parseEnumArray("B, A", labels), equalTo((ListInt) ArrayInteger.of(1, 0)));
210+
// assertThat(f.parseEnumArray("B, A, C,A", labels), equalTo((ListInt) ArrayInteger.of(1, 0, 2, 0)));
211+
// }
212+
213+
}

0 commit comments

Comments
 (0)