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

   1 /**
   2  * Copyright (c) 2010-2023 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.mybmw.internal.dto;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.openhab.binding.mybmw.internal.MyBMWConstants.*;
  17
  18 import java.util.HashMap;
  19 import java.util.List;
  20 import java.util.Map;
  21
  22 import javax.measure.Unit;
  23 import javax.measure.quantity.Length;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.openhab.binding.mybmw.internal.MyBMWConstants.VehicleType;
  28 import org.openhab.binding.mybmw.internal.dto.properties.CBS;
  29 import org.openhab.binding.mybmw.internal.dto.vehicle.Vehicle;
  30 import org.openhab.binding.mybmw.internal.handler.VehicleTests;
  31 import org.openhab.binding.mybmw.internal.utils.Constants;
  32 import org.openhab.binding.mybmw.internal.utils.Converter;
  33 import org.openhab.binding.mybmw.internal.utils.VehicleStatusUtils;
  34 import org.openhab.core.library.types.DateTimeType;
  35 import org.openhab.core.library.types.OnOffType;
  36 import org.openhab.core.library.types.PointType;
  37 import org.openhab.core.library.types.QuantityType;
  38 import org.openhab.core.library.types.StringType;
  39 import org.openhab.core.library.unit.ImperialUnits;
  40 import org.openhab.core.library.unit.SIUnits;
  41 import org.openhab.core.library.unit.Units;
  42 import org.openhab.core.thing.ChannelUID;
  43 import org.openhab.core.types.State;
  44 import org.openhab.core.types.UnDefType;
  45
  46 /**
  47  * The {@link StatusWrapper} tests stored fingerprint responses from BMW API
  48  *
  49  * @author Bernd Weymann - Initial contribution
  50  */
  51 @NonNullByDefault
  52 @SuppressWarnings("null")
  53 public class StatusWrapper {
  54     private static final Unit<Length> KILOMETRE = Constants.KILOMETRE_UNIT;
  55
  56     private Vehicle vehicle;
  57     private boolean isElectric;
  58     private boolean hasFuel;
  59     private boolean isHybrid;
  60
  61     private Map<String, State> specialHandlingMap = new HashMap<String, State>();
  62
  63     public StatusWrapper(String type, String statusJson) {
  64         hasFuel = type.equals(VehicleType.CONVENTIONAL.toString()) || type.equals(VehicleType.PLUGIN_HYBRID.toString())
  65                 || type.equals(VehicleType.ELECTRIC_REX.toString()) || type.equals(VehicleType.MILD_HYBRID.toString());
  66         isElectric = type.equals(VehicleType.PLUGIN_HYBRID.toString())
  67                 || type.equals(VehicleType.ELECTRIC_REX.toString()) || type.equals(VehicleType.ELECTRIC.toString());
  68         isHybrid = hasFuel && isElectric;
  69         List<Vehicle> vl = Converter.getVehicleList(statusJson);
  70         assertEquals(1, vl.size(), "Vehciles found");
  71         vehicle = Converter.getConsistentVehcile(vl.get(0));
  72     }
  73
  74     /**
  75      * Test results auctomatically against json values
  76      *
  77      * @param channels
  78      * @param states
  79      * @return
  80      */
  81     public boolean checkResults(@Nullable List<ChannelUID> channels, @Nullable List<State> states) {
  82         assertNotNull(channels);
  83         assertNotNull(states);
  84         assertTrue(channels.size() == states.size(), "Same list sizes");
  85         for (int i = 0; i < channels.size(); i++) {
  86             checkResult(channels.get(i), states.get(i));
  87         }
  88         return true;
  89     }
  90
  91     /**
  92      * Add a specific check for a value e.g. hard coded "Upcoming Service" in order to check the right ordering
  93      *
  94      * @param specialHand
  95      * @return
  96      */
  97     public StatusWrapper append(Map<String, State> compareMap) {
  98         specialHandlingMap.putAll(compareMap);
  99         return this;
 100     }
 101
 102     @SuppressWarnings({ "unchecked", "rawtypes" })
 103     private void checkResult(ChannelUID channelUID, State state) {
 104         String cUid = channelUID.getIdWithoutGroup();
 105         String gUid = channelUID.getGroupId();
 106         QuantityType<Length> qt;
 107         StringType st;
 108         StringType wanted;
 109         DateTimeType dtt;
 110         PointType pt;
 111         OnOffType oot;
 112         Unit<Length> wantedUnit;
 113         switch (cUid) {
 114             case MILEAGE:
 115                 switch (gUid) {
 116                     case CHANNEL_GROUP_RANGE:
 117                         if (!state.equals(UnDefType.UNDEF)) {
 118                             assertTrue(state instanceof QuantityType);
 119                             qt = ((QuantityType) state);
 120                             if (Constants.KM_JSON.equals(vehicle.status.currentMileage.units)) {
 121                                 assertEquals(KILOMETRE, qt.getUnit(), "KM");
 122                             } else {
 123                                 assertEquals(ImperialUnits.MILE, qt.getUnit(), "Miles");
 124                             }
 125                             assertEquals(qt.intValue(), vehicle.status.currentMileage.mileage, "Mileage");
 126                         } else {
 127                             assertEquals(Constants.INT_UNDEF, vehicle.status.currentMileage.mileage,
 128                                     "Mileage undefined");
 129                         }
 130                         break;
 131                     case CHANNEL_GROUP_SERVICE:
 132                         State wantedMileage = QuantityType.valueOf(Constants.INT_UNDEF, Constants.KILOMETRE_UNIT);
 133                         if (!vehicle.properties.serviceRequired.isEmpty()) {
 134                             if (vehicle.properties.serviceRequired.get(0).distance != null) {
 135                                 if (vehicle.properties.serviceRequired.get(0).distance.units
 136                                         .equals(Constants.KILOMETERS_JSON)) {
 137                                     wantedMileage = QuantityType.valueOf(
 138                                             vehicle.properties.serviceRequired.get(0).distance.value,
 139                                             Constants.KILOMETRE_UNIT);
 140                                 } else {
 141                                     wantedMileage = QuantityType.valueOf(
 142                                             vehicle.properties.serviceRequired.get(0).distance.value,
 143                                             ImperialUnits.MILE);
 144                                 }
 145                             }
 146                         }
 147                         assertEquals(wantedMileage, state, "Service Mileage");
 148                         break;
 149                     default:
 150                         assertFalse(true, "Channel " + channelUID + " " + state + " not found");
 151                         break;
 152                 }
 153                 break;
 154             case RANGE_ELECTRIC:
 155                 assertTrue(isElectric, "Is Electric");
 156                 assertTrue(state instanceof QuantityType);
 157                 qt = ((QuantityType) state);
 158                 wantedUnit = VehicleStatusUtils.getLengthUnit(vehicle.status.fuelIndicators);
 159                 assertEquals(wantedUnit, qt.getUnit());
 160                 assertEquals(VehicleStatusUtils.getRange(Constants.UNIT_PRECENT_JSON, vehicle), qt.intValue(),
 161                         "Range Electric");
 162                 break;
 163             case RANGE_FUEL:
 164                 assertTrue(hasFuel, "Has Fuel");
 165                 assertTrue(state instanceof QuantityType);
 166                 qt = ((QuantityType) state);
 167                 wantedUnit = VehicleStatusUtils.getLengthUnit(vehicle.status.fuelIndicators);
 168                 assertEquals(wantedUnit, qt.getUnit());
 169                 assertEquals(VehicleStatusUtils.getRange(Constants.UNIT_LITER_JSON, vehicle), qt.intValue(),
 170                         "Range Combustion");
 171                 break;
 172             case RANGE_HYBRID:
 173                 assertTrue(isHybrid, "Is Hybrid");
 174                 assertTrue(state instanceof QuantityType);
 175                 qt = ((QuantityType) state);
 176                 wantedUnit = VehicleStatusUtils.getLengthUnit(vehicle.status.fuelIndicators);
 177                 assertEquals(wantedUnit, qt.getUnit());
 178                 assertEquals(VehicleStatusUtils.getRange(Constants.PHEV, vehicle), qt.intValue(), "Range Combined");
 179                 break;
 180             case REMAINING_FUEL:
 181                 assertTrue(hasFuel, "Has Fuel");
 182                 assertTrue(state instanceof QuantityType);
 183                 qt = ((QuantityType) state);
 184                 assertEquals(Units.LITRE, qt.getUnit(), "Liter Unit");
 185                 assertEquals(vehicle.properties.fuelLevel.value, qt.intValue(), "Fuel Level");
 186                 break;
 187             case SOC:
 188                 assertTrue(isElectric, "Is Ee<lctric");
 189                 assertTrue(state instanceof QuantityType);
 190                 qt = ((QuantityType) state);
 191                 assertEquals(Units.PERCENT, qt.getUnit(), "Percent");
 192                 assertEquals(vehicle.properties.chargingState.chargePercentage, qt.intValue(), "Charge Level");
 193                 break;
 194             case LOCK:
 195                 assertTrue(state instanceof StringType);
 196                 st = (StringType) state;
 197                 assertEquals(Converter.getLockState(vehicle.properties.areDoorsLocked), st, "Vehicle locked");
 198                 break;
 199             case DOORS:
 200                 assertTrue(state instanceof StringType);
 201                 st = (StringType) state;
 202                 assertEquals(Converter.getClosedState(vehicle.properties.areDoorsClosed), st, "Doors Closed");
 203                 break;
 204             case WINDOWS:
 205                 assertTrue(state instanceof StringType);
 206                 st = (StringType) state;
 207                 if (specialHandlingMap.containsKey(WINDOWS)) {
 208                     assertEquals(specialHandlingMap.get(WINDOWS).toString(), st.toString(), "Windows");
 209                 } else {
 210                     assertEquals(Converter.getClosedState(vehicle.properties.areWindowsClosed), st, "Windows");
 211                 }
 212
 213                 break;
 214             case CHECK_CONTROL:
 215                 assertTrue(state instanceof StringType);
 216                 st = (StringType) state;
 217                 if (specialHandlingMap.containsKey(CHECK_CONTROL)) {
 218                     assertEquals(specialHandlingMap.get(CHECK_CONTROL).toString(), st.toString(), "Check Control");
 219                 } else {
 220                     assertEquals(vehicle.status.checkControlMessagesGeneralState, st.toString(), "Check Control");
 221                 }
 222                 break;
 223             case CHARGE_INFO:
 224                 assertTrue(isElectric, "Is Electric");
 225                 assertTrue(state instanceof StringType);
 226                 st = (StringType) state;
 227                 assertEquals(Converter.getLocalTime(VehicleStatusUtils.getChargeInfo(vehicle)), st.toString(),
 228                         "Charge Info");
 229                 break;
 230             case CHARGE_STATUS:
 231                 assertTrue(isElectric, "Is Electric");
 232                 assertTrue(state instanceof StringType);
 233                 st = (StringType) state;
 234                 assertEquals(Converter.toTitleCase(VehicleStatusUtils.getChargStatus(vehicle)), st.toString(),
 235                         "Charge Status");
 236                 break;
 237             case PLUG_CONNECTION:
 238                 assertTrue(state instanceof StringType);
 239                 st = (StringType) state;
 240                 assertEquals(Converter.getConnectionState(vehicle.properties.chargingState.isChargerConnected), st,
 241                         "Plug Connection State");
 242                 break;
 243             case LAST_UPDATE:
 244                 assertTrue(state instanceof DateTimeType);
 245                 dtt = (DateTimeType) state;
 246                 DateTimeType expected = DateTimeType
 247                         .valueOf(Converter.zonedToLocalDateTime(vehicle.properties.lastUpdatedAt));
 248                 assertEquals(expected.toString(), dtt.toString(), "Last Update");
 249                 break;
 250             case GPS:
 251                 if (state instanceof PointType) {
 252                     pt = (PointType) state;
 253                     assertNotNull(vehicle.properties.vehicleLocation);
 254                     assertEquals(
 255                             PointType.valueOf(Double.toString(vehicle.properties.vehicleLocation.coordinates.latitude)
 256                                     + "," + Double.toString(vehicle.properties.vehicleLocation.coordinates.longitude)),
 257                             pt, "Coordinates");
 258                 } // else no check needed
 259                 break;
 260             case HEADING:
 261                 if (state instanceof QuantityType) {
 262                     qt = ((QuantityType) state);
 263                     assertEquals(Units.DEGREE_ANGLE, qt.getUnit(), "Angle Unit");
 264                     assertNotNull(vehicle.properties.vehicleLocation);
 265                     assertEquals(vehicle.properties.vehicleLocation.heading, qt.intValue(), 0.01, "Heading");
 266                 } // else no check needed
 267                 break;
 268             case RANGE_RADIUS_ELECTRIC:
 269                 assertTrue(state instanceof QuantityType);
 270                 assertTrue(isElectric);
 271                 qt = ((QuantityType) state);
 272                 wantedUnit = VehicleStatusUtils.getLengthUnit(vehicle.status.fuelIndicators);
 273                 assertEquals(wantedUnit, qt.getUnit());
 274                 assertEquals(
 275                         Converter.guessRangeRadius(VehicleStatusUtils.getRange(Constants.UNIT_PRECENT_JSON, vehicle)),
 276                         qt.intValue(), "Range Radius Electric");
 277                 break;
 278             case RANGE_RADIUS_FUEL:
 279                 assertTrue(state instanceof QuantityType);
 280                 assertTrue(hasFuel);
 281                 qt = (QuantityType) state;
 282                 wantedUnit = VehicleStatusUtils.getLengthUnit(vehicle.status.fuelIndicators);
 283                 assertEquals(wantedUnit, qt.getUnit());
 284                 assertEquals(
 285                         Converter.guessRangeRadius(VehicleStatusUtils.getRange(Constants.UNIT_LITER_JSON, vehicle)),
 286                         qt.intValue(), "Range Radius Fuel");
 287                 break;
 288             case RANGE_RADIUS_HYBRID:
 289                 assertTrue(state instanceof QuantityType);
 290                 assertTrue(isHybrid);
 291                 qt = (QuantityType) state;
 292                 wantedUnit = VehicleStatusUtils.getLengthUnit(vehicle.status.fuelIndicators);
 293                 assertEquals(wantedUnit, qt.getUnit());
 294                 assertEquals(Converter.guessRangeRadius(VehicleStatusUtils.getRange(Constants.PHEV, vehicle)),
 295                         qt.intValue(), "Range Radius Combined");
 296                 break;
 297             case DOOR_DRIVER_FRONT:
 298                 assertTrue(state instanceof StringType);
 299                 st = (StringType) state;
 300                 wanted = StringType
 301                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.doors.driverFront));
 302                 assertEquals(wanted.toString(), st.toString(), "Door");
 303                 break;
 304             case DOOR_DRIVER_REAR:
 305                 assertTrue(state instanceof StringType);
 306                 st = (StringType) state;
 307                 wanted = StringType.valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.doors.driverRear));
 308                 assertEquals(wanted.toString(), st.toString(), "Door");
 309                 break;
 310             case DOOR_PASSENGER_FRONT:
 311                 assertTrue(state instanceof StringType);
 312                 st = (StringType) state;
 313                 wanted = StringType
 314                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.doors.passengerFront));
 315                 assertEquals(wanted.toString(), st.toString(), "Door");
 316                 break;
 317             case DOOR_PASSENGER_REAR:
 318                 assertTrue(state instanceof StringType);
 319                 st = (StringType) state;
 320                 wanted = StringType
 321                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.doors.passengerRear));
 322                 assertEquals(wanted.toString(), st.toString(), "Door");
 323                 break;
 324             case TRUNK:
 325                 assertTrue(state instanceof StringType);
 326                 st = (StringType) state;
 327                 wanted = StringType.valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.trunk));
 328                 assertEquals(wanted.toString(), st.toString(), "Door");
 329                 break;
 330             case HOOD:
 331                 assertTrue(state instanceof StringType);
 332                 st = (StringType) state;
 333                 wanted = StringType.valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.hood));
 334                 assertEquals(wanted.toString(), st.toString(), "Door");
 335                 break;
 336             case WINDOW_DOOR_DRIVER_FRONT:
 337                 assertTrue(state instanceof StringType);
 338                 st = (StringType) state;
 339                 wanted = StringType
 340                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.windows.driverFront));
 341                 assertEquals(wanted.toString(), st.toString(), "Window");
 342                 break;
 343             case WINDOW_DOOR_DRIVER_REAR:
 344                 assertTrue(state instanceof StringType);
 345                 st = (StringType) state;
 346                 wanted = StringType
 347                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.windows.driverRear));
 348                 assertEquals(wanted.toString(), st.toString(), "Window");
 349                 break;
 350             case WINDOW_DOOR_PASSENGER_FRONT:
 351                 assertTrue(state instanceof StringType);
 352                 st = (StringType) state;
 353                 wanted = StringType
 354                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.windows.passengerFront));
 355                 assertEquals(wanted.toString(), st.toString(), "Window");
 356                 break;
 357             case WINDOW_DOOR_PASSENGER_REAR:
 358                 assertTrue(state instanceof StringType);
 359                 st = (StringType) state;
 360                 wanted = StringType
 361                         .valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.windows.passengerRear));
 362                 assertEquals(wanted.toString(), st.toString(), "Window");
 363                 break;
 364             case SUNROOF:
 365                 assertTrue(state instanceof StringType);
 366                 st = (StringType) state;
 367                 wanted = StringType.valueOf(Converter.toTitleCase(vehicle.properties.doorsAndWindows.moonroof));
 368                 assertEquals(wanted.toString(), st.toString(), "Window");
 369                 break;
 370             case SERVICE_DATE:
 371                 if (!state.equals(UnDefType.UNDEF)) {
 372                     assertTrue(state instanceof DateTimeType);
 373                     dtt = (DateTimeType) state;
 374                     if (gUid.contentEquals(CHANNEL_GROUP_STATUS)) {
 375                         if (specialHandlingMap.containsKey(SERVICE_DATE)) {
 376                             assertEquals(specialHandlingMap.get(SERVICE_DATE).toString(), dtt.toString(),
 377                                     "Next Service");
 378                         } else {
 379                             String dueDateString = VehicleStatusUtils
 380                                     .getNextServiceDate(vehicle.properties.serviceRequired).toString();
 381                             DateTimeType expectedDTT = DateTimeType.valueOf(dueDateString);
 382                             assertEquals(expectedDTT.toString(), dtt.toString(), "Next Service");
 383                         }
 384                     } else if (gUid.equals(CHANNEL_GROUP_SERVICE)) {
 385                         String dueDateString = vehicle.properties.serviceRequired.get(0).dateTime;
 386                         DateTimeType expectedDTT = DateTimeType.valueOf(Converter.zonedToLocalDateTime(dueDateString));
 387                         assertEquals(expectedDTT.toString(), dtt.toString(), "First Service Date");
 388                     }
 389                 }
 390                 break;
 391             case SERVICE_MILEAGE:
 392                 if (!state.equals(UnDefType.UNDEF)) {
 393                     qt = ((QuantityType) state);
 394                     if (gUid.contentEquals(CHANNEL_GROUP_STATUS)) {
 395                         QuantityType<Length> wantedQt = (QuantityType) VehicleStatusUtils
 396                                 .getNextServiceMileage(vehicle.properties.serviceRequired);
 397                         assertEquals(wantedQt.getUnit(), qt.getUnit(), "Next Service Miles");
 398                         assertEquals(wantedQt.intValue(), qt.intValue(), "Mileage");
 399                     } else if (gUid.equals(CHANNEL_GROUP_SERVICE)) {
 400                         assertEquals(vehicle.properties.serviceRequired.get(0).distance.units, qt.getUnit(),
 401                                 "First Service Unit");
 402                         assertEquals(vehicle.properties.serviceRequired.get(0).distance.value, qt.intValue(),
 403                                 "First Service Mileage");
 404                     }
 405                 }
 406                 break;
 407             case NAME:
 408                 assertTrue(state instanceof StringType);
 409                 st = (StringType) state;
 410                 switch (gUid) {
 411                     case CHANNEL_GROUP_SERVICE:
 412                         wanted = StringType.valueOf(Constants.NO_ENTRIES);
 413                         if (!vehicle.properties.serviceRequired.isEmpty()) {
 414                             wanted = StringType
 415                                     .valueOf(Converter.toTitleCase(vehicle.properties.serviceRequired.get(0).type));
 416                         }
 417                         assertEquals(wanted.toString(), st.toString(), "Service Name");
 418                         break;
 419                     case CHANNEL_GROUP_CHECK_CONTROL:
 420                         wanted = StringType.valueOf(Constants.NO_ENTRIES);
 421                         if (!vehicle.status.checkControlMessages.isEmpty()) {
 422                             wanted = StringType.valueOf(vehicle.status.checkControlMessages.get(0).title);
 423                         }
 424                         assertEquals(wanted.toString(), st.toString(), "CheckControl Name");
 425                         break;
 426                     default:
 427                         assertFalse(true, "Channel " + channelUID + " " + state + " not found");
 428                         break;
 429                 }
 430                 break;
 431             case DETAILS:
 432                 assertTrue(state instanceof StringType);
 433                 st = (StringType) state;
 434                 switch (gUid) {
 435                     case CHANNEL_GROUP_SERVICE:
 436                         wanted = StringType.valueOf(Converter.toTitleCase(Constants.NO_ENTRIES));
 437                         if (!vehicle.properties.serviceRequired.isEmpty()) {
 438                             wanted = StringType
 439                                     .valueOf(Converter.toTitleCase(vehicle.properties.serviceRequired.get(0).type));
 440                         }
 441                         assertEquals(wanted.toString(), st.toString(), "Service Details");
 442                         break;
 443                     case CHANNEL_GROUP_CHECK_CONTROL:
 444                         wanted = StringType.valueOf(Constants.NO_ENTRIES);
 445                         if (!vehicle.status.checkControlMessages.isEmpty()) {
 446                             wanted = StringType.valueOf(vehicle.status.checkControlMessages.get(0).longDescription);
 447                         }
 448                         assertEquals(wanted.toString(), st.toString(), "CheckControl Details");
 449                         break;
 450                     default:
 451                         assertFalse(true, "Channel " + channelUID + " " + state + " not found");
 452                         break;
 453                 }
 454                 break;
 455             case SEVERITY:
 456                 assertTrue(state instanceof StringType);
 457                 st = (StringType) state;
 458                 wanted = StringType.valueOf(Constants.NO_ENTRIES);
 459                 if (!vehicle.status.checkControlMessages.isEmpty()) {
 460                     wanted = StringType.valueOf(vehicle.status.checkControlMessages.get(0).state);
 461                 }
 462                 assertEquals(wanted.toString(), st.toString(), "CheckControl Details");
 463                 break;
 464             case DATE:
 465                 if (state.equals(UnDefType.UNDEF)) {
 466                     for (CBS serviceEntry : vehicle.properties.serviceRequired) {
 467                         assertTrue(serviceEntry.dateTime == null, "No Service Date available");
 468                     }
 469                 } else {
 470                     assertTrue(state instanceof DateTimeType);
 471                     dtt = (DateTimeType) state;
 472                     switch (gUid) {
 473                         case CHANNEL_GROUP_SERVICE:
 474                             String dueDateString = vehicle.properties.serviceRequired.get(0).dateTime;
 475                             DateTimeType expectedDTT = DateTimeType
 476                                     .valueOf(Converter.zonedToLocalDateTime(dueDateString));
 477                             assertEquals(expectedDTT.toString(), dtt.toString(), "ServiceSate");
 478                             break;
 479                         default:
 480                             assertFalse(true, "Channel " + channelUID + " " + state + " not found");
 481                             break;
 482                     }
 483                 }
 484                 break;
 485             case FRONT_LEFT_CURRENT:
 486                 if (vehicle.properties.tires != null) {
 487                     assertTrue(state instanceof QuantityType);
 488                     qt = (QuantityType) state;
 489                     assertEquals(vehicle.properties.tires.frontLeft.status.currentPressure / 100, qt.doubleValue(),
 490                             "Fron Left Current");
 491                 } else {
 492                     assertTrue(state.equals(UnDefType.UNDEF));
 493                 }
 494                 break;
 495             case FRONT_LEFT_TARGET:
 496                 if (vehicle.properties.tires != null) {
 497                     assertTrue(state instanceof QuantityType);
 498                     qt = (QuantityType) state;
 499                     assertEquals(vehicle.properties.tires.frontLeft.status.targetPressure / 100, qt.doubleValue(),
 500                             "Fron Left Current");
 501                 } else {
 502                     assertTrue(state.equals(UnDefType.UNDEF));
 503                 }
 504                 break;
 505             case FRONT_RIGHT_CURRENT:
 506                 if (vehicle.properties.tires != null) {
 507                     assertTrue(state instanceof QuantityType);
 508                     qt = (QuantityType) state;
 509                     assertEquals(vehicle.properties.tires.frontRight.status.currentPressure / 100, qt.doubleValue(),
 510                             "Fron Left Current");
 511                 } else {
 512                     assertTrue(state.equals(UnDefType.UNDEF));
 513                 }
 514                 break;
 515             case FRONT_RIGHT_TARGET:
 516                 if (vehicle.properties.tires != null) {
 517                     assertTrue(state instanceof QuantityType);
 518                     qt = (QuantityType) state;
 519                     assertEquals(vehicle.properties.tires.frontRight.status.targetPressure / 100, qt.doubleValue(),
 520                             "Fron Left Current");
 521                 } else {
 522                     assertTrue(state.equals(UnDefType.UNDEF));
 523                 }
 524                 break;
 525             case REAR_LEFT_CURRENT:
 526                 if (vehicle.properties.tires != null) {
 527                     assertTrue(state instanceof QuantityType);
 528                     qt = (QuantityType) state;
 529                     assertEquals(vehicle.properties.tires.rearLeft.status.currentPressure / 100, qt.doubleValue(),
 530                             "Fron Left Current");
 531                 } else {
 532                     assertTrue(state.equals(UnDefType.UNDEF));
 533                 }
 534                 break;
 535             case REAR_LEFT_TARGET:
 536                 if (vehicle.properties.tires != null) {
 537                     assertTrue(state instanceof QuantityType);
 538                     qt = (QuantityType) state;
 539                     assertEquals(vehicle.properties.tires.rearLeft.status.targetPressure / 100, qt.doubleValue(),
 540                             "Fron Left Current");
 541                 } else {
 542                     assertTrue(state.equals(UnDefType.UNDEF));
 543                 }
 544                 break;
 545             case REAR_RIGHT_CURRENT:
 546                 if (vehicle.properties.tires != null) {
 547                     assertTrue(state instanceof QuantityType);
 548                     qt = (QuantityType) state;
 549                     assertEquals(vehicle.properties.tires.rearRight.status.currentPressure / 100, qt.doubleValue(),
 550                             "Fron Left Current");
 551                 } else {
 552                     assertTrue(state.equals(UnDefType.UNDEF));
 553                 }
 554                 break;
 555             case REAR_RIGHT_TARGET:
 556                 if (vehicle.properties.tires != null) {
 557                     assertTrue(state instanceof QuantityType);
 558                     qt = (QuantityType) state;
 559                     assertEquals(vehicle.properties.tires.rearRight.status.targetPressure / 100, qt.doubleValue(),
 560                             "Fron Left Current");
 561                 } else {
 562                     assertTrue(state.equals(UnDefType.UNDEF));
 563                 }
 564                 break;
 565             case MOTION:
 566                 assertTrue(state instanceof OnOffType);
 567                 oot = (OnOffType) state;
 568                 if (vehicle.properties.inMotion) {
 569                     assertEquals(oot.toFullString(), OnOffType.ON.toFullString(), "Vehicle Driving");
 570                 } else {
 571                     assertEquals(oot.toFullString(), OnOffType.OFF.toFullString(), "Vehicle Stationary");
 572                 }
 573                 break;
 574             case ADDRESS:
 575                 if (state instanceof StringType) {
 576                     st = (StringType) state;
 577                     assertEquals(st.toFullString(), vehicle.properties.vehicleLocation.address.formatted,
 578                             "Location Address");
 579                 } // else no check needed
 580                 break;
 581             case HOME_DISTANCE:
 582                 if (state instanceof QuantityType) {
 583                     qt = (QuantityType) state;
 584                     PointType vehicleLocation = PointType
 585                             .valueOf(Double.toString(vehicle.properties.vehicleLocation.coordinates.latitude) + ","
 586                                     + Double.toString(vehicle.properties.vehicleLocation.coordinates.longitude));
 587                     int distance = vehicleLocation.distanceFrom(VehicleTests.HOME_LOCATION).intValue();
 588                     assertEquals(qt.intValue(), distance, "Distance from Home");
 589                     assertEquals(qt.getUnit(), SIUnits.METRE, "Distance from Home Unit");
 590                 } // else no check needed
 591                 break;
 592             case RAW:
 593                 // don't assert raw channel
 594                 break;
 595             default:
 596                 if (!gUid.equals(CHANNEL_GROUP_CHARGE_PROFILE)) {
 597                     // fail in case of unknown update
 598                     assertFalse(true, "Channel " + channelUID + " " + state + " not found");
 599                 }
 600                 break;
 601         }
 602     }
 603 }