git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2020 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.siemensrds.test;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.openhab.binding.siemensrds.internal.RdsBindingConstants.*;
  17
  18 import java.io.BufferedReader;
  19 import java.io.FileReader;
  20 import java.io.IOException;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Map.Entry;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.junit.jupiter.api.Test;
  28 import org.openhab.binding.siemensrds.internal.RdsAccessToken;
  29 import org.openhab.binding.siemensrds.internal.RdsCloudException;
  30 import org.openhab.binding.siemensrds.internal.RdsDataPoints;
  31 import org.openhab.binding.siemensrds.internal.RdsPlants;
  32 import org.openhab.binding.siemensrds.internal.RdsPlants.PlantInfo;
  33 import org.openhab.binding.siemensrds.points.BasePoint;
  34 import org.openhab.core.library.types.DecimalType;
  35 import org.openhab.core.library.types.QuantityType;
  36 import org.openhab.core.library.types.StringType;
  37 import org.openhab.core.library.unit.ImperialUnits;
  38 import org.openhab.core.library.unit.SIUnits;
  39 import org.openhab.core.types.State;
  40
  41 import tec.uom.se.unit.Units;
  42
  43 /**
  44  * test suite
  45  *
  46  * @author Andrew Fiddian-Green - Initial contribution
  47  *
  48  */
  49 @NonNullByDefault
  50 public class RdsTestData {
  51
  52     private String load(String fileName) {
  53         try (FileReader file = new FileReader(String.format("src/test/resources/%s.json", fileName));
  54                 BufferedReader reader = new BufferedReader(file)) {
  55             StringBuilder builder = new StringBuilder();
  56             String line;
  57             while ((line = reader.readLine()) != null) {
  58                 builder.append(line).append("\n");
  59             }
  60             return builder.toString();
  61         } catch (IOException e) {
  62             fail(e.getMessage());
  63         }
  64         return "";
  65     }
  66
  67     @Test
  68     public void testRdsDataPointsFullNew() {
  69         RdsDataPoints dataPoints = RdsDataPoints.createFromJson(load("datapoints_full_set_new"));
  70         assertNotNull(dataPoints);
  71         try {
  72             assertEquals("Downstairs", dataPoints.getDescription());
  73         } catch (RdsCloudException e) {
  74             fail(e.getMessage());
  75         }
  76         @Nullable
  77         Map<String, @Nullable BasePoint> points = dataPoints.points;
  78         assertNotNull(points);
  79         assertEquals(70, points.size());
  80     }
  81
  82     @Test
  83     public void confirmDegreeSymbolCodingNotTrashed() {
  84         /*
  85          * note: temperature symbols with a degree sign: the MVN Spotless trashes the
  86          * "degree" (looks like *) symbol, so we must escape these symbols as octal \260
  87          * or unicode \u00B00 - the following test will indicate is all is ok
  88          */
  89         assertTrue("\260C".equals(BasePoint.DEGREES_CELSIUS));
  90         assertTrue("\u00B0C".equals(BasePoint.DEGREES_CELSIUS));
  91         assertTrue("\260F".equals(BasePoint.DEGREES_FAHRENHEIT));
  92         assertTrue("\u00B0F".equals(BasePoint.DEGREES_FAHRENHEIT));
  93         assertTrue(BasePoint.DEGREES_FAHRENHEIT.startsWith(BasePoint.DEGREES_CELSIUS.substring(0, 1)));
  94     }
  95
  96     @Test
  97     public void testRdsDataPointsRefresh() {
  98         RdsDataPoints refreshPoints = RdsDataPoints.createFromJson(load("datapoints_refresh_set"));
  99         assertNotNull(refreshPoints);
 100
 101         assertNotNull(refreshPoints.points);
 102         Map<String, @Nullable BasePoint> refreshMap = refreshPoints.points;
 103         assertNotNull(refreshMap);
 104
 105         @Nullable
 106         BasePoint point;
 107         State state;
 108
 109         // check the parsed values
 110         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;0!Online");
 111         assertTrue(point instanceof BasePoint);
 112         state = point.getState();
 113         assertEquals(state.getClass(), DecimalType.class);
 114         assertEquals(1, ((DecimalType) state).intValue());
 115
 116         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!00000000E000055");
 117         assertTrue(point instanceof BasePoint);
 118         state = point.getState();
 119         assertEquals(state.getClass(), QuantityType.class);
 120         assertEquals(12.60, ((QuantityType<?>) state).floatValue(), 0.01);
 121
 122         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!002000083000055");
 123         assertTrue(point instanceof BasePoint);
 124         state = point.getState();
 125         assertEquals(state.getClass(), QuantityType.class);
 126         assertEquals(16.0, ((QuantityType<?>) state).floatValue(), 0.01);
 127
 128         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!002000085000055");
 129         assertTrue(point instanceof BasePoint);
 130         state = point.getState();
 131         assertEquals(state.getClass(), QuantityType.class);
 132         assertEquals(39.13, ((QuantityType<?>) state).floatValue(), 0.01);
 133
 134         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!002000086000055");
 135         assertTrue(point instanceof BasePoint);
 136         state = point.getState();
 137         assertEquals(state.getClass(), QuantityType.class);
 138         assertEquals(21.51, ((QuantityType<?>) state).floatValue(), 0.01);
 139
 140         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!013000051000055");
 141         assertTrue(point instanceof BasePoint);
 142         state = point.getState();
 143         assertEquals(state.getClass(), QuantityType.class);
 144         assertEquals(2, ((QuantityType<?>) state).intValue());
 145
 146         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!013000052000055");
 147         assertTrue(point instanceof BasePoint);
 148         state = point.getState();
 149         assertEquals(state.getClass(), QuantityType.class);
 150         assertEquals(5, ((QuantityType<?>) state).intValue());
 151
 152         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!013000053000055");
 153         assertTrue(point instanceof BasePoint);
 154         state = point.getState();
 155         assertEquals(state.getClass(), QuantityType.class);
 156         assertEquals(2, ((QuantityType<?>) state).intValue());
 157
 158         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!013000056000055");
 159         assertTrue(point instanceof BasePoint);
 160         state = point.getState();
 161         assertEquals(state.getClass(), QuantityType.class);
 162         assertEquals(1, ((QuantityType<?>) state).intValue());
 163
 164         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!01300005A000055");
 165         assertTrue(point instanceof BasePoint);
 166         state = point.getState();
 167         assertEquals(state.getClass(), QuantityType.class);
 168         assertEquals(2, ((QuantityType<?>) state).intValue());
 169
 170         point = refreshMap.get("Pd1774247-7de7-4896-ac76-b7e0dd943c40;1!013000074000055");
 171         assertTrue(point instanceof BasePoint);
 172         state = point.getState();
 173         assertEquals(state.getClass(), QuantityType.class);
 174         assertEquals(4, ((QuantityType<?>) state).intValue());
 175
 176         RdsDataPoints originalPoints = RdsDataPoints.createFromJson(load("datapoints_full_set"));
 177         assertNotNull(originalPoints);
 178         assertNotNull(originalPoints.points);
 179
 180         // check that the refresh point types match the originals
 181         Map<String, @Nullable BasePoint> originalMap = originalPoints.points;
 182         assertNotNull(originalMap);
 183         @Nullable
 184         BasePoint refreshPoint;
 185         @Nullable
 186         BasePoint originalPoint;
 187         for (String key : refreshMap.keySet()) {
 188             refreshPoint = refreshMap.get(key);
 189             assertTrue(refreshPoint instanceof BasePoint);
 190             originalPoint = originalMap.get(key);
 191             assertTrue(originalPoint instanceof BasePoint);
 192             assertEquals(refreshPoint.getState().getClass(), originalPoint.getState().getClass());
 193         }
 194     }
 195
 196     @Test
 197     public void testAccessToken() {
 198         RdsAccessToken accessToken = RdsAccessToken.createFromJson(load("access_token"));
 199         assertNotNull(accessToken);
 200         try {
 201             assertEquals("this-is-not-a-valid-access_token", accessToken.getToken());
 202         } catch (RdsCloudException e) {
 203             fail(e.getMessage());
 204         }
 205         assertTrue(accessToken.isExpired());
 206     }
 207
 208     @Test
 209     public void testRdsDataPointsFull() {
 210         RdsDataPoints dataPoints = RdsDataPoints.createFromJson(load("datapoints_full_set"));
 211         assertNotNull(dataPoints);
 212         try {
 213             assertEquals("Upstairs", dataPoints.getDescription());
 214         } catch (RdsCloudException e) {
 215             fail(e.getMessage());
 216         }
 217
 218         @Nullable
 219         Map<String, @Nullable BasePoint> points = dataPoints.points;
 220         assertNotNull(points);
 221         assertEquals(67, points.size());
 222
 223         try {
 224             assertEquals("AAS-20:SU=SiUn;APT=HvacFnct18z_A;APTV=2.003;APS=1;",
 225                     dataPoints.getPointByClass("ApplicationSoftwareVersion").getState().toString());
 226             assertEquals("Device object", dataPoints.getPointByClass("Device Description").getState().toString());
 227             assertEquals("FW=02.32.02.27;SVS-300.1:SBC=13.22;I",
 228                     dataPoints.getPointByClass("FirmwareRevision").getState().toString());
 229             assertEquals("RDS110", dataPoints.getPointByClass("ModelName").getState().toString());
 230             assertEquals(0, dataPoints.getPointByClass("SystemStatus").asInt());
 231             assertEquals(0, dataPoints.getPointByClass("UtcOffset").asInt());
 232             assertEquals(19, dataPoints.getPointByClass("DatabaseRevision").asInt());
 233             assertEquals(0, dataPoints.getPointByClass("LastRestartReason").asInt());
 234             assertEquals("MDL:ASN= RDS110;HW=0.2.0;",
 235                     dataPoints.getPointByClass("ModelInformation").getState().toString());
 236             assertEquals(1, dataPoints.getPointByClass("Active SystemLanguge").asInt());
 237             assertEquals(26, dataPoints.getPointByClass("TimeZone").asInt());
 238             assertEquals("160100096D", dataPoints.getPointByClass("SerialNumber").getState().toString());
 239             assertEquals("'10010'B", dataPoints.getPointByClass("Device Features").getState().toString());
 240             assertEquals("Upstairs", dataPoints.getPointByClass("'Description").getState().toString());
 241             assertEquals("192.168.1.1", dataPoints.getPointByClass("'IP gefault gateway").getState().toString());
 242             assertEquals("255.255.255.0", dataPoints.getPointByClass("'IP subnet mask").getState().toString());
 243             assertEquals("192.168.1.42", dataPoints.getPointByClass("'IP address").getState().toString());
 244             assertEquals(47808, dataPoints.getPointByClass("'UDP Port").asInt());
 245             assertEquals("'F0C77F6C1895'H", dataPoints.getPointByClass("'BACnet MAC address").getState().toString());
 246             assertEquals("sth.connectivity.ccl-siemens.com",
 247                     dataPoints.getPointByClass("'Connection URI").getState().toString());
 248             assertEquals("this-is-not-a-valid-activation-key",
 249                     dataPoints.getPointByClass("'Activation Key").getState().toString());
 250             assertEquals(60, dataPoints.getPointByClass("'Reconection delay").asInt());
 251             assertEquals(0, dataPoints.getPointByClass("#Item Updates per Minute").asInt());
 252             assertEquals(286849, dataPoints.getPointByClass("#Item Updates Total").asInt());
 253             assertEquals("-;en", dataPoints.getPointByClass("#Languages").getState().toString());
 254             assertEquals(1, dataPoints.getPointByClass("#Online").asInt());
 255             assertEquals(1473, dataPoints.getPointByClass("#Traffic Inbound per Minute").asInt());
 256             assertEquals(178130801, dataPoints.getPointByClass("#Traffic Inbound Total").asInt());
 257             assertEquals(616, dataPoints.getPointByClass("#Traffic Outbound per Minute").asInt());
 258             assertEquals(60624666, dataPoints.getPointByClass("#Traffic Outbound Total").asInt());
 259             assertEquals(0, dataPoints.getPointByClass("#Item Updates per Minute").asInt());
 260
 261             State state;
 262             QuantityType<?> celsius;
 263
 264             state = dataPoints.getPointByClass("'TOa").getState();
 265             assertTrue(state instanceof QuantityType<?>);
 266             celsius = ((QuantityType<?>) state).toUnit(SIUnits.CELSIUS);
 267             assertNotNull(celsius);
 268             assertEquals(18.55, celsius.floatValue(), 0.01);
 269
 270             assertEquals("0.0", dataPoints.getPointByClass("'HDevElLd").getState().toString());
 271
 272             state = dataPoints.getPointByClass("'SpHPcf").getState();
 273             assertTrue(state instanceof QuantityType<?>);
 274             QuantityType<?> fahrenheit = ((QuantityType<?>) state).toUnit(ImperialUnits.FAHRENHEIT);
 275             assertNotNull(fahrenheit);
 276             assertEquals(24.00, fahrenheit.floatValue(), 0.01);
 277
 278             state = dataPoints.getPointByClass("'SpHEco").getState();
 279             assertTrue(state instanceof QuantityType<?>);
 280             celsius = ((QuantityType<?>) state).toUnit(SIUnits.CELSIUS);
 281             assertNotNull(celsius);
 282             assertEquals(16.00, celsius.floatValue(), 0.01);
 283
 284             state = dataPoints.getPointByClass("'SpHPrt").getState();
 285             assertTrue(state instanceof QuantityType<?>);
 286             celsius = ((QuantityType<?>) state).toUnit(SIUnits.CELSIUS);
 287             assertNotNull(celsius);
 288             assertEquals(6.00, celsius.floatValue(), 0.01);
 289
 290             state = dataPoints.getPointByClass("'SpTR").getState();
 291             assertTrue(state instanceof QuantityType<?>);
 292             celsius = ((QuantityType<?>) state).toUnit(SIUnits.CELSIUS);
 293             assertNotNull(celsius);
 294             assertEquals(24.00, celsius.floatValue(), 0.01);
 295
 296             state = dataPoints.getPointByClass("'SpTRShft").getState();
 297             assertTrue(state instanceof QuantityType<?>);
 298             QuantityType<?> kelvin = ((QuantityType<?>) state).toUnit(Units.KELVIN);
 299             assertNotNull(kelvin);
 300             assertEquals(0, kelvin.floatValue(), 0.01);
 301
 302             state = dataPoints.getPointByClass("'RHuRel").getState();
 303             assertTrue(state instanceof QuantityType<?>);
 304             QuantityType<?> relativeHumidity = ((QuantityType<?>) state).toUnit(Units.PERCENT);
 305             assertNotNull(relativeHumidity);
 306             assertEquals(46.86865, relativeHumidity.floatValue(), 0.1);
 307
 308             state = dataPoints.getPointByClass("'RTemp").getState();
 309             assertTrue(state instanceof QuantityType<?>);
 310             celsius = ((QuantityType<?>) state).toUnit(SIUnits.CELSIUS);
 311             assertNotNull(celsius);
 312             assertEquals(23.76, celsius.floatValue(), 0.01);
 313
 314             state = dataPoints.getPointByClass("'SpTRMaxHCmf").getState();
 315             assertTrue(state instanceof QuantityType<?>);
 316             celsius = ((QuantityType<?>) state).toUnit(SIUnits.CELSIUS);
 317             assertNotNull(celsius);
 318             assertEquals(35.00, celsius.floatValue(), 0.01);
 319
 320             assertEquals("30.0", dataPoints.getPointByClass("'WarmUpGrdnt").getState().toString());
 321
 322             state = dataPoints.getPointByClass("'TRBltnMsvAdj").getState();
 323             assertTrue(state instanceof QuantityType<?>);
 324             kelvin = ((QuantityType<?>) state).toUnit(Units.KELVIN);
 325             assertNotNull(kelvin);
 326             assertEquals(35.0, celsius.floatValue(), 0.01);
 327
 328             assertEquals("0.0", dataPoints.getPointByClass("'Q22Q24ElLd").getState().toString());
 329             assertEquals("713.0", dataPoints.getPointByClass("'RAQual").getState().toString());
 330             assertEquals("0.0", dataPoints.getPointByClass("'TmpCmfBtn").getState().toString());
 331             assertEquals("0.0", dataPoints.getPointByClass("'CmfBtn").getState().toString());
 332             assertEquals("0.0", dataPoints.getPointByClass("'RPscDet").getState().toString());
 333             assertEquals("1.0", dataPoints.getPointByClass("'EnHCtl").getState().toString());
 334             assertEquals("0.0", dataPoints.getPointByClass("'EnRPscDet").getState().toString());
 335             assertEquals("2.0", dataPoints.getPointByClass("'OffPrtCnf").getState().toString());
 336             assertEquals("3.0", dataPoints.getPointByClass("'OccMod").getState().toString());
 337             assertEquals("5.0", dataPoints.getPointByClass("'REei").getState().toString());
 338             assertEquals("2.0", dataPoints.getPointByClass("'DhwMod").getState().toString());
 339             assertEquals("2.0", dataPoints.getPointByClass("'HCSta").getState().toString());
 340             assertEquals("4.0", dataPoints.getPointByClass("'PrOpModRsn").getState().toString());
 341             assertEquals("6.0", dataPoints.getPointByClass("'HCtrSet").getState().toString());
 342             assertEquals("2.0", dataPoints.getPointByClass("'OsscSet").getState().toString());
 343             assertEquals("4.0", dataPoints.getPointByClass("'RAQualInd").getState().toString());
 344             assertEquals("500.0", dataPoints.getPointByClass("'KickCyc").getState().toString());
 345             assertEquals("180000.0", dataPoints.getPointByClass("'BoDhwTiOnMin").getState().toString());
 346             assertEquals("180000.0", dataPoints.getPointByClass("'BoDhwTiOffMin").getState().toString());
 347             assertEquals("UNDEF", dataPoints.getPointByClass("'ROpModSched").getState().toString());
 348             assertEquals("UNDEF", dataPoints.getPointByClass("'DhwSched").getState().toString());
 349             assertEquals("UNDEF", dataPoints.getPointByClass("'ROpModSched").getState().toString());
 350             assertEquals("UNDEF", dataPoints.getPointByClass("'DhwSched").getState().toString());
 351             assertEquals("253140.0", dataPoints.getPointByClass("'OphH").getState().toString());
 352         } catch (RdsCloudException e) {
 353             fail(e.getMessage());
 354         }
 355
 356         // test for a missing element
 357         State test = null;
 358         try {
 359             test = dataPoints.getPointByClass("missing-element").getState();
 360             fail("expected exception did not occur");
 361         } catch (RdsCloudException e) {
 362             assertEquals(null, test);
 363         }
 364
 365         try {
 366             // test the all-the-way-round lookup loop
 367             assertNotNull(dataPoints.points);
 368             Map<String, @Nullable BasePoint> pointsMap = dataPoints.points;
 369             assertNotNull(pointsMap);
 370             @Nullable
 371             BasePoint point;
 372             for (Entry<String, @Nullable BasePoint> entry : pointsMap.entrySet()) {
 373                 point = entry.getValue();
 374                 assertTrue(point instanceof BasePoint);
 375                 // ignore UNDEF points where all-the-way-round lookup fails
 376                 if (!"UNDEF".equals(point.getState().toString())) {
 377                     @Nullable
 378                     String x = entry.getKey();
 379                     assertNotNull(x);
 380                     String y = ((BasePoint) point).getPointClass();
 381                     String z = dataPoints.pointClassToId(y);
 382                     assertEquals(x, z);
 383                 }
 384             }
 385
 386             State state = null;
 387
 388             // test the specific points that we use
 389             state = dataPoints.getPointByClass(HIE_DESCRIPTION).getState();
 390             assertEquals("Upstairs", state.toString());
 391
 392             state = dataPoints.getPointByClass(HIE_ROOM_TEMP).getState();
 393             assertEquals(state.getClass(), QuantityType.class);
 394             assertEquals(23.761879, ((QuantityType<?>) state).floatValue(), 0.01);
 395
 396             state = dataPoints.getPointByClass(HIE_OUTSIDE_TEMP).getState();
 397             assertEquals(state.getClass(), QuantityType.class);
 398             assertEquals(18.55, ((QuantityType<?>) state).floatValue(), 0.01);
 399
 400             state = dataPoints.getPointByClass(HIE_TARGET_TEMP).getState();
 401             assertEquals(state.getClass(), QuantityType.class);
 402             assertEquals(24, ((QuantityType<?>) state).floatValue(), 0.01);
 403
 404             state = dataPoints.getPointByClass(HIE_ROOM_HUMIDITY).getState();
 405             assertEquals(state.getClass(), QuantityType.class);
 406             assertEquals(46.86, ((QuantityType<?>) state).floatValue(), 0.01);
 407
 408             state = dataPoints.getPointByClass(HIE_ROOM_AIR_QUALITY).getEnum();
 409             assertEquals(state.getClass(), StringType.class);
 410             assertEquals("Good", state.toString());
 411             assertEquals("Good", dataPoints.getPointByClass(HIE_ROOM_AIR_QUALITY).getEnum().toString());
 412
 413             state = dataPoints.getPointByClass(HIE_ENERGY_SAVINGS_LEVEL).getEnum();
 414             assertEquals(state.getClass(), StringType.class);
 415             assertEquals("Excellent", state.toString());
 416             assertEquals("Excellent", dataPoints.getPointByClass(HIE_ENERGY_SAVINGS_LEVEL).getEnum().toString());
 417
 418             state = dataPoints.getPointByClass(HIE_OUTPUT_STATE).getEnum();
 419             assertEquals(state.getClass(), StringType.class);
 420             assertEquals("Heating", state.toString());
 421             assertEquals("Heating", dataPoints.getPointByClass(HIE_OUTPUT_STATE).getEnum().toString());
 422
 423             state = dataPoints.getPointByClass(HIE_STAT_OCC_MODE_PRESENT).getState();
 424             assertEquals(state.getClass(), QuantityType.class);
 425             assertEquals(3, ((QuantityType<?>) state).intValue());
 426             assertEquals(3, dataPoints.getPointByClass(HIE_STAT_OCC_MODE_PRESENT).asInt());
 427
 428             state = dataPoints.getPointByClass(HIE_STAT_OCC_MODE_PRESENT).getEnum();
 429             assertEquals(state.getClass(), StringType.class);
 430             assertEquals("Present", state.toString());
 431             assertEquals("Present", dataPoints.getPointByClass(HIE_STAT_OCC_MODE_PRESENT).getEnum().toString());
 432
 433             state = dataPoints.getPointByClass(HIE_DHW_OUTPUT_STATE).getState();
 434             assertEquals(state.getClass(), QuantityType.class);
 435             assertEquals(2, ((QuantityType<?>) state).intValue());
 436             assertEquals(2, dataPoints.getPointByClass(HIE_DHW_OUTPUT_STATE).asInt());
 437
 438             state = dataPoints.getPointByClass(HIE_DHW_OUTPUT_STATE).getEnum();
 439             assertEquals(state.getClass(), StringType.class);
 440             assertEquals("On", state.toString());
 441             assertEquals("On", dataPoints.getPointByClass(HIE_DHW_OUTPUT_STATE).getEnum().toString());
 442
 443             state = dataPoints.getPointByClass(HIE_PR_OP_MOD_RSN).getState();
 444             assertEquals(state.getClass(), QuantityType.class);
 445             assertEquals(4, ((QuantityType<?>) state).intValue());
 446             assertEquals(4, dataPoints.getPointByClass(HIE_PR_OP_MOD_RSN).asInt());
 447
 448             state = dataPoints.getPointByClass(HIE_PR_OP_MOD_RSN).getEnum();
 449             assertEquals(state.getClass(), StringType.class);
 450             assertEquals("Comfort", state.toString());
 451             assertEquals("Comfort", dataPoints.getPointByClass(HIE_PR_OP_MOD_RSN).getEnum().toString());
 452
 453             state = dataPoints.getPointByClass(HIE_STAT_CMF_BTN).getState();
 454             assertEquals(state.getClass(), QuantityType.class);
 455             assertEquals(0, ((QuantityType<?>) state).intValue());
 456             assertEquals(0, dataPoints.getPointByClass(HIE_STAT_CMF_BTN).asInt());
 457
 458             state = dataPoints.getPointByClass(HIE_STAT_CMF_BTN).getEnum();
 459             assertEquals(state.getClass(), StringType.class);
 460             assertEquals("Inactive", state.toString());
 461             assertEquals("Inactive", dataPoints.getPointByClass(HIE_STAT_CMF_BTN).getEnum().toString());
 462
 463             // test online code
 464             assertTrue(dataPoints.isOnline());
 465
 466             // test present priority code
 467             assertEquals(15, dataPoints.getPointByClass(HIE_TARGET_TEMP).getPresentPriority());
 468
 469             // test temperature units code (C)
 470             BasePoint tempPoint = dataPoints.getPointByClass("'SpTR");
 471             assertTrue(tempPoint instanceof BasePoint);
 472             assertEquals(SIUnits.CELSIUS, ((BasePoint) tempPoint).getUnit());
 473
 474             // test temperature units code (F)
 475             tempPoint = dataPoints.getPointByClass("'SpHPcf");
 476             assertTrue(tempPoint instanceof BasePoint);
 477             assertEquals(ImperialUnits.FAHRENHEIT, ((BasePoint) tempPoint).getUnit());
 478
 479             // test temperature units code (K)
 480             tempPoint = dataPoints.getPointByClass("'SpHPcf");
 481             assertTrue(tempPoint instanceof BasePoint);
 482             assertEquals(ImperialUnits.FAHRENHEIT, ((BasePoint) tempPoint).getUnit());
 483
 484             tempPoint = dataPoints.getPointByClass("'SpTRShft");
 485             assertTrue(tempPoint instanceof BasePoint);
 486             assertEquals(Units.KELVIN, ((BasePoint) tempPoint).getUnit());
 487         } catch (RdsCloudException e) {
 488             fail(e.getMessage());
 489         }
 490     }
 491
 492     @Test
 493     public void testRdsPlants() {
 494         try {
 495             RdsPlants plants = RdsPlants.createFromJson(load("plants"));
 496             assertNotNull(plants);
 497
 498             @Nullable
 499             List<PlantInfo> plantList = plants.getPlants();
 500             assertNotNull(plantList);
 501
 502             @Nullable
 503             PlantInfo plant;
 504             plant = plantList.get(0);
 505             assertTrue(plant instanceof PlantInfo);
 506             assertEquals("Pd1774247-7de7-4896-ac76-b7e0dd943c40", ((PlantInfo) plant).getId());
 507             assertTrue(plant.isOnline());
 508
 509             plant = plantList.get(1);
 510             assertTrue(plant instanceof PlantInfo);
 511             assertEquals("Pfaf770c8-abeb-4742-ad65-ead39030d369", ((PlantInfo) plant).getId());
 512             assertTrue(((PlantInfo) plant).isOnline());
 513         } catch (RdsCloudException e) {
 514             fail(e.getMessage());
 515         }
 516     }
 517 }