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

   1 /**
   2  * Copyright (c) 2010-2022 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.hdpowerview;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.openhab.binding.hdpowerview.internal.api.CoordinateSystem.*;
  17
  18 import org.eclipse.jdt.annotation.NonNullByDefault;
  19 import org.junit.jupiter.api.Test;
  20 import org.openhab.binding.hdpowerview.internal.api.ShadePosition;
  21 import org.openhab.binding.hdpowerview.internal.database.ShadeCapabilitiesDatabase;
  22 import org.openhab.binding.hdpowerview.internal.database.ShadeCapabilitiesDatabase.Capabilities;
  23 import org.openhab.core.library.types.PercentType;
  24 import org.openhab.core.types.State;
  25 import org.openhab.core.types.UnDefType;
  26
  27 /**
  28  * Unit tests for Shade Position setting and getting.
  29  *
  30  * @author Andrew Fiddian-Green - Initial contribution
  31  */
  32 @NonNullByDefault
  33 public class ShadePositionTest {
  34
  35     private final ShadeCapabilitiesDatabase db = new ShadeCapabilitiesDatabase();
  36
  37     /**
  38      * General tests of the database of known types.
  39      */
  40     @Test
  41     public void testKnownTypesDatabase() {
  42         assertTrue(db.isTypeInDatabase(4));
  43         assertTrue(db.isCapabilitiesInDatabase(0));
  44
  45         assertTrue(db.getCapabilities(0).supportsPrimary());
  46         assertTrue(db.getCapabilities(0).supportsTiltOnClosed());
  47         assertTrue(db.getCapabilities(1).supportsTiltOnClosed());
  48         assertTrue(db.getCapabilities(2).supportsTilt180());
  49         assertTrue(db.getCapabilities(3).supportsTiltOnClosed());
  50         assertTrue(db.getCapabilities(4).supportsTilt180());
  51         assertTrue(db.getCapabilities(5).supportsTilt180());
  52         assertFalse(db.getCapabilities(5).supportsPrimary());
  53         assertTrue(db.getCapabilities(6).isPrimaryStateInverted());
  54         assertTrue(db.getCapabilities(7).supportsSecondary());
  55         assertTrue(db.getCapabilities(8).supportsBlackoutShade());
  56         assertTrue(db.getCapabilities(9).supportsBlackoutShade());
  57
  58         assertEquals(db.getType(4).getCapabilities(), 0);
  59         assertEquals(db.getType(-1).getCapabilities(), -1);
  60
  61         assertFalse(db.isTypeInDatabase(99));
  62         assertFalse(db.isCapabilitiesInDatabase(99));
  63
  64         assertFalse(db.getCapabilities(0).isPrimaryStateInverted());
  65         assertFalse(db.getCapabilities(-1).isPrimaryStateInverted());
  66         assertFalse(db.getCapabilities(99).isPrimaryStateInverted());
  67
  68         assertFalse(db.getCapabilities(0).supportsSecondary());
  69         assertFalse(db.getCapabilities(-1).supportsSecondary());
  70         assertFalse(db.getCapabilities(99).supportsSecondary());
  71     }
  72
  73     /**
  74      * Helper method; test if shade position is a PercentType and that its value is correct.
  75      *
  76      * @param position the shade position
  77      * @param value the test value to compare with
  78      */
  79     private void assertShadePosition(State position, int value) {
  80         assertEquals(PercentType.class, position.getClass());
  81         assertEquals(value, ((PercentType) position).intValue());
  82     }
  83
  84     /**
  85      * Test parsing of ShadePosition (shade fully up).
  86      *
  87      */
  88     @Test
  89     public void testShadePositionParsingFullyUp() {
  90         Capabilities capabilities = db.getCapabilities(0);
  91         ShadePosition test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 0);
  92         assertNotNull(test);
  93         State pos = test.getState(capabilities, PRIMARY_POSITION);
  94         assertShadePosition(pos, 0);
  95         pos = test.getState(capabilities, VANE_TILT_POSITION);
  96         assertTrue(UnDefType.UNDEF.equals(pos));
  97     }
  98
  99     /**
 100      * Test parsing of ShadePosition (shade fully down (method 1)).
 101      *
 102      */
 103     @Test
 104     public void testShadePositionParsingShadeFullyDown1() {
 105         Capabilities capabilities = db.getCapabilities(0);
 106         ShadePosition test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 100);
 107         assertNotNull(test);
 108         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 109         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 0);
 110     }
 111
 112     /**
 113      * Test parsing of ShadePosition (shade fully down (method 2)).
 114      *
 115      */
 116     @Test
 117     public void testShadePositionParsingShadeFullyDown2() {
 118         Capabilities capabilities = db.getCapabilities(0);
 119         ShadePosition test = new ShadePosition().setPosition(capabilities, VANE_TILT_POSITION, 0);
 120         assertNotNull(test);
 121         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 122         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 0);
 123     }
 124
 125     /**
 126      * Test parsing of ShadePosition (shade fully down (method 2) and vane fully open).
 127      *
 128      */
 129     @Test
 130     public void testShadePositionParsingShadeFullyDownVaneOpen() {
 131         Capabilities capabilities = db.getCapabilities(0);
 132         ShadePosition test = new ShadePosition().setPosition(capabilities, VANE_TILT_POSITION, 100);
 133         assertNotNull(test);
 134         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 135         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 100);
 136     }
 137
 138     /**
 139      * On dual rail shades, it should not be possible to drive the upper rail below the lower rail, or vice-versa. So
 140      * the binding code applies constraints on setting such positions. This test checks that the constraint code is
 141      * working.
 142      */
 143     @Test
 144     public void testDualRailConstraints() {
 145         Capabilities capabilities = db.getCapabilities(7);
 146         ShadePosition test = new ShadePosition();
 147
 148         // ==== OK !! primary at bottom, secondary at top ====
 149         test.setPosition(capabilities, PRIMARY_POSITION, 100).setPosition(capabilities, SECONDARY_POSITION, 0);
 150         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 151         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 152
 153         // ==== OK !! primary at middle, secondary at top ====
 154         test.setPosition(capabilities, PRIMARY_POSITION, 50).setPosition(capabilities, SECONDARY_POSITION, 0);
 155         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 50);
 156         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 157
 158         // ==== OK !! primary at middle, secondary at middle ====
 159         test.setPosition(capabilities, PRIMARY_POSITION, 50).setPosition(capabilities, SECONDARY_POSITION, 50);
 160         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 50);
 161         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 50);
 162
 163         // ==== IMPOSSIBLE !! secondary at middle, primary above => test the constraining code ====
 164         test.setPosition(capabilities, SECONDARY_POSITION, 0).setPosition(capabilities, PRIMARY_POSITION, 100);
 165         test.setPosition(capabilities, SECONDARY_POSITION, 40).setPosition(capabilities, PRIMARY_POSITION, 25);
 166         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 40);
 167         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 40);
 168
 169         // ==== OK !! secondary at middle, primary below ====
 170         test.setPosition(capabilities, SECONDARY_POSITION, 0).setPosition(capabilities, PRIMARY_POSITION, 100);
 171         test.setPosition(capabilities, SECONDARY_POSITION, 50).setPosition(capabilities, PRIMARY_POSITION, 75);
 172         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 75);
 173         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 50);
 174
 175         // ==== IMPOSSIBLE !! primary at middle, secondary below => test the constraining code ====
 176         test.setPosition(capabilities, SECONDARY_POSITION, 0).setPosition(capabilities, PRIMARY_POSITION, 100);
 177         test.setPosition(capabilities, PRIMARY_POSITION, 60).setPosition(capabilities, SECONDARY_POSITION, 75);
 178         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 60);
 179         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 60);
 180
 181         // ==== OK !! primary at middle, secondary above ====
 182         test.setPosition(capabilities, SECONDARY_POSITION, 0).setPosition(capabilities, PRIMARY_POSITION, 100);
 183         test.setPosition(capabilities, PRIMARY_POSITION, 60).setPosition(capabilities, SECONDARY_POSITION, 25);
 184         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 60);
 185         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 25);
 186     }
 187
 188     /**
 189      * Test parsing of DuoLite shades having a secondary blackout shade.
 190      *
 191      */
 192     @Test
 193     public void testDuoliteShadePositionParsing() {
 194         // blackout shades have capabilities 8
 195         Capabilities capabilities = db.getCapabilities(8);
 196         ShadePosition test;
 197
 198         // both shades up
 199         test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 0);
 200         assertNotNull(test);
 201         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 0);
 202         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 203
 204         // front shade 50% down
 205         test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 50);
 206         assertNotNull(test);
 207         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 50);
 208         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 209
 210         // front shade 100% down, back shade 0% down
 211         test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 100);
 212         assertNotNull(test);
 213         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 214         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 215
 216         // front shade 100% down, back shade 0% down (ALTERNATE)
 217         test = new ShadePosition().setPosition(capabilities, SECONDARY_POSITION, 0);
 218         assertNotNull(test);
 219         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 220         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 221
 222         // front shade 100% down, back shade 50% down
 223         test = new ShadePosition().setPosition(capabilities, SECONDARY_POSITION, 50);
 224         assertNotNull(test);
 225         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 226         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 50);
 227
 228         // front shade 100% down, back shade 100% down
 229         test = new ShadePosition().setPosition(capabilities, SECONDARY_POSITION, 100);
 230         assertNotNull(test);
 231         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 232         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 100);
 233     }
 234
 235     /**
 236      * Test parsing of DuoLite shades having both a secondary blackout shade, and tilt anywhere functionality.
 237      *
 238      */
 239     @Test
 240     public void testDuoliteTiltShadePositionParsing() {
 241         // blackout shades with tilt have capabilities 9
 242         Capabilities capabilities = db.getCapabilities(9);
 243         ShadePosition test;
 244
 245         // both shades up, tilt 0%
 246         test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 0).setPosition(capabilities,
 247                 VANE_TILT_POSITION, 0);
 248         assertNotNull(test);
 249         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 0);
 250         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 251
 252         // front shade 50% down, tilt 30%
 253         test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 50).setPosition(capabilities,
 254                 VANE_TILT_POSITION, 30);
 255         assertNotNull(test);
 256         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 50);
 257         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 258         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 30);
 259
 260         // front shade 100% down, back shade 0% down, tilt 30%
 261         test = new ShadePosition().setPosition(capabilities, PRIMARY_POSITION, 100).setPosition(capabilities,
 262                 VANE_TILT_POSITION, 30);
 263         assertNotNull(test);
 264         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 265         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 266         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 30);
 267
 268         // front shade 100% down, back shade 0% down, tilt 30% (ALTERNATE)
 269         test = new ShadePosition().setPosition(capabilities, SECONDARY_POSITION, 0).setPosition(capabilities,
 270                 VANE_TILT_POSITION, 30);
 271         assertNotNull(test);
 272         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 273         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 0);
 274         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 30);
 275
 276         // front shade 100% down, back shade 50% down, tilt 30%
 277         test = new ShadePosition().setPosition(capabilities, SECONDARY_POSITION, 50).setPosition(capabilities,
 278                 VANE_TILT_POSITION, 30);
 279         assertNotNull(test);
 280         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 281         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 50);
 282         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 30);
 283
 284         // front shade 100% down, back shade 100% down, tilt 70%
 285         test = new ShadePosition().setPosition(capabilities, SECONDARY_POSITION, 100).setPosition(capabilities,
 286                 VANE_TILT_POSITION, 70);
 287         assertNotNull(test);
 288         assertShadePosition(test.getState(capabilities, PRIMARY_POSITION), 100);
 289         assertShadePosition(test.getState(capabilities, SECONDARY_POSITION), 100);
 290         assertShadePosition(test.getState(capabilities, VANE_TILT_POSITION), 70);
 291     }
 292 }