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

   1 /**
   2  * Copyright (c) 2010-2021 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.icalendar.internal.logic;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16
  17 import java.io.FileInputStream;
  18 import java.io.IOException;
  19 import java.time.Instant;
  20 import java.util.List;
  21
  22 import org.junit.jupiter.api.BeforeEach;
  23 import org.junit.jupiter.api.Test;
  24 import org.openhab.core.library.types.HSBType;
  25 import org.openhab.core.library.types.OnOffType;
  26 import org.openhab.core.library.types.OpenClosedType;
  27 import org.openhab.core.library.types.PercentType;
  28 import org.openhab.core.library.types.PlayPauseType;
  29 import org.openhab.core.library.types.QuantityType;
  30 import org.openhab.core.library.types.RewindFastforwardType;
  31 import org.openhab.core.library.types.StringType;
  32 import org.openhab.core.library.types.UpDownType;
  33 import org.openhab.core.types.Command;
  34
  35 /**
  36  * Tests for presentable calendar.
  37  *
  38  * @author Michael Wodniok - Initial contribution.
  39  * @author Andrew Fiddian-Green - Tests for Command Tag code
  40  * @author Michael Wodniok - Extended Tests for filtered Events
  41  *
  42  */
  43 public class BiweeklyPresentableCalendarTest {
  44     private AbstractPresentableCalendar calendar;
  45     private AbstractPresentableCalendar calendar2;
  46     private AbstractPresentableCalendar calendar3;
  47
  48     @BeforeEach
  49     public void setUp() throws IOException, CalendarException {
  50         calendar = new BiweeklyPresentableCalendar(new FileInputStream("src/test/resources/test.ics"));
  51         calendar2 = new BiweeklyPresentableCalendar(new FileInputStream("src/test/resources/test2.ics"));
  52         calendar3 = new BiweeklyPresentableCalendar(new FileInputStream("src/test/resources/test3.ics"));
  53     }
  54
  55     /**
  56      * Tests recurrence and whether TimeZone is interpolated in a right way.
  57      */
  58     @Test
  59     public void testIsEventPresent() {
  60         // Test series
  61         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-08T09:04:00Z")));
  62         assertTrue(calendar.isEventPresent(Instant.parse("2019-09-08T09:08:00Z")));
  63         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-08T09:11:00Z")));
  64
  65         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-09T09:04:00Z")));
  66         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-09T09:08:00Z")));
  67         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-09T09:11:00Z")));
  68
  69         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-10T09:04:00Z")));
  70         assertTrue(calendar.isEventPresent(Instant.parse("2019-09-10T09:08:00Z")));
  71         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-10T09:11:00Z")));
  72
  73         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-11T09:04:00Z")));
  74         assertTrue(calendar.isEventPresent(Instant.parse("2019-09-11T09:08:00Z")));
  75         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-11T09:11:00Z")));
  76
  77         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-12T09:04:00Z")));
  78         assertTrue(calendar.isEventPresent(Instant.parse("2019-09-12T09:08:00Z")));
  79         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-12T09:11:00Z")));
  80
  81         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-13T09:04:00Z")));
  82         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-13T09:08:00Z")));
  83         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-13T09:11:00Z")));
  84
  85         // Test in CEST (UTC+2)
  86         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-14T07:59:00Z")));
  87         assertTrue(calendar.isEventPresent(Instant.parse("2019-09-14T08:03:00Z")));
  88         assertFalse(calendar.isEventPresent(Instant.parse("2019-09-14T09:01:00Z")));
  89
  90         // Test Series with cancelled event by Davdroid
  91         assertFalse(calendar2.isEventPresent(Instant.parse("2019-11-03T09:55:00Z")));
  92         assertTrue(calendar2.isEventPresent(Instant.parse("2019-11-03T10:01:00Z")));
  93         assertFalse(calendar2.isEventPresent(Instant.parse("2019-11-03T13:00:00Z")));
  94
  95         assertFalse(calendar2.isEventPresent(Instant.parse("2019-11-24T09:55:00Z")));
  96         assertFalse(calendar2.isEventPresent(Instant.parse("2019-11-24T10:01:00Z")));
  97         assertFalse(calendar2.isEventPresent(Instant.parse("2019-11-24T13:00:00Z")));
  98     }
  99
 100     /**
 101      * This test relies on a working isEventPresent and assumes the calculation
 102      * of recurrence is done the same way.
 103      */
 104     @Test
 105     public void testGetCurrentEvent() {
 106         Event currentEvent = calendar.getCurrentEvent(Instant.parse("2019-09-10T09:07:00Z"));
 107         assertNotNull(currentEvent);
 108         assertTrue("Test Series in UTC".contentEquals(currentEvent.title));
 109         assertEquals(0, Instant.parse("2019-09-10T09:05:00Z").compareTo(currentEvent.start));
 110         assertEquals(0, Instant.parse("2019-09-10T09:10:00Z").compareTo(currentEvent.end));
 111
 112         Event nonExistingEvent = calendar.getCurrentEvent(Instant.parse("2019-09-09T09:07:00Z"));
 113         assertNull(nonExistingEvent);
 114     }
 115
 116     /**
 117      * This test relies on a working isEventPresent and assumes the calculation
 118      * of recurrence is done the same way.
 119      */
 120     @Test
 121     public void testGetNextEvent() {
 122         // positive case: next event of series
 123         Event nextEventOfSeries = calendar.getNextEvent(Instant.parse("2019-09-10T09:07:00Z"));
 124         assertNotNull(nextEventOfSeries);
 125         assertTrue("Test Series in UTC".contentEquals(nextEventOfSeries.title));
 126         assertEquals(0, Instant.parse("2019-09-11T09:05:00Z").compareTo(nextEventOfSeries.start));
 127         assertEquals(0, Instant.parse("2019-09-11T09:10:00Z").compareTo(nextEventOfSeries.end));
 128
 129         // positive case: next event after series
 130         Event nextEventOutsideSeries = calendar.getNextEvent(Instant.parse("2019-09-12T09:07:00Z"));
 131         assertNotNull(nextEventOutsideSeries);
 132         assertTrue("Test Event in UTC+2".contentEquals(nextEventOutsideSeries.title));
 133         assertEquals(0, Instant.parse("2019-09-14T08:00:00Z").compareTo(nextEventOutsideSeries.start));
 134         assertEquals(0, Instant.parse("2019-09-14T09:00:00Z").compareTo(nextEventOutsideSeries.end));
 135
 136         // positive case: next event should be also set if currently none is present
 137         Event nextEventIndependent = calendar.getNextEvent(Instant.parse("2019-09-13T09:07:00Z"));
 138         assertTrue(nextEventOutsideSeries.equals(nextEventIndependent));
 139
 140         // negative case: after last event there is no next
 141         Event nonExistingEvent = calendar.getNextEvent(Instant.parse("2019-09-14T12:00:00Z"));
 142         assertNull(nonExistingEvent);
 143
 144         // mixed case: cancelled events also not show up as next
 145         Event nextEventAfterCancelled = calendar2.getNextEvent(Instant.parse("2019-11-24T09:55:00Z"));
 146         assertNotNull(nextEventAfterCancelled);
 147         assertEquals(0, Instant.parse("2019-12-01T10:00:00Z").compareTo(nextEventAfterCancelled.start));
 148     }
 149
 150     /**
 151      * This test checks for Events that have just begun or ended, and if so it checks for Command Tags
 152      * and checks if these tags are valid
 153      */
 154     @SuppressWarnings("null")
 155     @Test
 156     public void testCommandTagCode() {
 157         List<Event> events = null;
 158         int eventCount = 2;
 159         int tagsPerEvent = 8;
 160
 161         // test just begun events: first in the series
 162         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T15:55:00Z"),
 163                 Instant.parse("2020-01-28T16:05:00Z"));
 164         assertNotNull(events);
 165         assertEquals(eventCount, events.size());
 166         for (Event event : events) {
 167             List<CommandTag> cmdTags = event.commandTags;
 168             assertEquals(tagsPerEvent, cmdTags.size());
 169             int beginTags = 0;
 170             for (CommandTag cmdTag : cmdTags) {
 171                 if (cmdTag.getTagType() == CommandTagType.BEGIN) {
 172                     assertTrue(cmdTag.isAuthorized("abc"));
 173                     assertTrue(cmdTag.getItemName().matches("^\\w+$"));
 174                     assertTrue(cmdTag.getCommand() != null);
 175                     beginTags++;
 176                 }
 177             }
 178             assertEquals(tagsPerEvent / 2, beginTags);
 179         }
 180
 181         // test just begun events: third in the series
 182         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-30T15:55:00Z"),
 183                 Instant.parse("2020-01-30T16:05:00Z"));
 184         assertNotNull(events);
 185         assertEquals(eventCount, events.size());
 186         for (Event event : events) {
 187             List<CommandTag> cmdTags = event.commandTags;
 188             assertEquals(tagsPerEvent, cmdTags.size());
 189             int beginTags = 0;
 190             for (CommandTag cmdTag : cmdTags) {
 191                 if (cmdTag.getTagType() == CommandTagType.BEGIN) {
 192                     assertTrue(cmdTag.isAuthorized("abc"));
 193                     assertTrue(cmdTag.getItemName().matches("^\\w+$"));
 194                     assertTrue(cmdTag.getCommand() != null);
 195                     beginTags++;
 196                 }
 197             }
 198             assertEquals(tagsPerEvent / 2, beginTags);
 199         }
 200
 201         // test outside of window: begun events, too early
 202         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T15:50:00Z"),
 203                 Instant.parse("2020-01-28T15:55:00Z"));
 204         assertNotNull(events);
 205         assertEquals(0, events.size());
 206
 207         // test outside of window: begun events, too late
 208         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T16:05:00Z"),
 209                 Instant.parse("2020-01-28T16:10:00Z"));
 210         assertNotNull(events);
 211         assertEquals(0, events.size());
 212
 213         // test just ended events: first in the series
 214         events = calendar3.getJustEndedEvents(Instant.parse("2020-01-28T16:25:00Z"),
 215                 Instant.parse("2020-01-28T16:35:00Z"));
 216         assertNotNull(events);
 217         assertEquals(eventCount, events.size());
 218         for (Event event : events) {
 219             List<CommandTag> cmdTags = event.commandTags;
 220             assertEquals(tagsPerEvent, cmdTags.size());
 221             int endTags = 0;
 222             for (CommandTag cmdTag : cmdTags) {
 223                 if (cmdTag.getTagType() == CommandTagType.END) {
 224                     assertTrue(cmdTag.isAuthorized("abc"));
 225                     assertTrue(cmdTag.getItemName().matches("^\\w+$"));
 226                     assertTrue(cmdTag.getCommand() != null);
 227                     endTags++;
 228                 }
 229             }
 230             assertEquals(tagsPerEvent / 2, endTags);
 231         }
 232
 233         // test outside of window: ended events, too early
 234         events = calendar3.getJustEndedEvents(Instant.parse("2020-01-28T16:20:00Z"),
 235                 Instant.parse("2020-01-28T16:25:00Z"));
 236         assertNotNull(events);
 237         assertEquals(0, events.size());
 238
 239         // test outside of window: ended events, too late
 240         events = calendar3.getJustEndedEvents(Instant.parse("2020-01-28T16:35:00Z"),
 241                 Instant.parse("2020-01-28T16:40:00Z"));
 242         assertNotNull(events);
 243         assertEquals(0, events.size());
 244
 245         // test a valid just begun event with both good and bad authorization codes
 246         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T15:55:00Z"),
 247                 Instant.parse("2020-01-28T16:05:00Z"));
 248         assertNotNull(events);
 249         assertTrue(events.size() > 0);
 250         List<CommandTag> cmdTags = events.get(0).commandTags;
 251         assertTrue(cmdTags.size() > 0);
 252         CommandTag cmd = cmdTags.get(0);
 253         // accept correct, empty or null configuration codes
 254         assertTrue(cmd.isAuthorized("abc"));
 255         assertTrue(cmd.isAuthorized(""));
 256         assertTrue(cmd.isAuthorized(null));
 257         // reject incorrect configuration code
 258         assertFalse(cmd.isAuthorized("123"));
 259
 260         // test tag syntax: Test Series #1
 261         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T19:25:00Z"),
 262                 Instant.parse("2020-01-28T19:35:00Z"));
 263         assertNotNull(events);
 264         assertEquals(1, events.size());
 265         cmdTags = events.get(0).commandTags;
 266         assertEquals(11, cmdTags.size());
 267
 268         // BEGIN:Calendar_Test_Color:ON:abc
 269         assertEquals("Calendar_Test_Color", cmdTags.get(0).getItemName());
 270         assertTrue(cmdTags.get(0).isAuthorized("abc"));
 271         Command cmd0 = cmdTags.get(0).getCommand();
 272         assertNotNull(cmd0);
 273         assertEquals(OnOffType.class, cmd0.getClass());
 274
 275         // BEGIN:Calendar_Test_Contact:OPEN:abc
 276         Command cmd1 = cmdTags.get(1).getCommand();
 277         assertNotNull(cmd1);
 278         assertEquals(OpenClosedType.class, cmd1.getClass());
 279
 280         // BEGIN:Calendar_Test_Dimmer:ON:abc
 281         Command cmd2 = cmdTags.get(2).getCommand();
 282         assertNotNull(cmd2);
 283         assertEquals(OnOffType.class, cmd2.getClass());
 284
 285         // BEGIN:Calendar_Test_Number:12.3:abc
 286         Command cmd3 = cmdTags.get(3).getCommand();
 287         assertNotNull(cmd3);
 288         assertEquals(QuantityType.class, cmd3.getClass());
 289
 290         // BEGIN:Calendar_Test_Temperature:12.3°C:abc
 291         Command cmd4 = cmdTags.get(4).getCommand();
 292         assertNotNull(cmd4);
 293         assertEquals(QuantityType.class, cmd4.getClass());
 294
 295         // BEGIN:Calendar_Test_Pressure:12.3hPa:abc
 296         Command cmd5 = cmdTags.get(5).getCommand();
 297         assertNotNull(cmd5);
 298         assertEquals(QuantityType.class, cmd5.getClass());
 299
 300         // BEGIN:Calendar_Test_Speed:12.3m/s:abc
 301         Command cmd6 = cmdTags.get(6).getCommand();
 302         assertNotNull(cmd6);
 303         assertEquals(QuantityType.class, cmd6.getClass());
 304
 305         // BEGIN:Calendar_Test_Player:PLAY:abc
 306         Command cmd7 = cmdTags.get(7).getCommand();
 307         assertNotNull(cmd7);
 308         assertEquals(PlayPauseType.class, cmd7.getClass());
 309
 310         // BEGIN:Calendar_Test_RollerShutter:UP:abc
 311         Command cmd8 = cmdTags.get(8).getCommand();
 312         assertNotNull(cmd8);
 313         assertEquals(UpDownType.class, cmd8.getClass());
 314
 315         // BEGIN:Calendar_Test_String:Test Series #1:abc
 316         Command cmd9 = cmdTags.get(9).getCommand();
 317         assertNotNull(cmd9);
 318         assertEquals(StringType.class, cmd9.getClass());
 319
 320         // BEGIN:Calendar_Test_Switch:ON:abc
 321         Command cmd10 = cmdTags.get(10).getCommand();
 322         assertNotNull(cmd10);
 323         assertEquals(OnOffType.class, cmd10.getClass());
 324
 325         // test tag syntax: Test Series #4
 326         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T20:10:00Z"),
 327                 Instant.parse("2020-01-28T20:20:00Z"));
 328         assertNotNull(events);
 329         assertEquals(1, events.size());
 330         cmdTags = events.get(0).commandTags;
 331         assertEquals(11, cmdTags.size());
 332
 333         // BEGIN:Calendar_Test_Color:0%:abc
 334         cmd0 = cmdTags.get(0).getCommand();
 335         assertNotNull(cmd0);
 336         assertEquals(PercentType.class, cmd0.getClass());
 337
 338         // BEGIN:Calendar_Test_Contact:CLOSED:abc
 339         cmd1 = cmdTags.get(1).getCommand();
 340         assertNotNull(cmd1);
 341         assertEquals(OpenClosedType.class, cmd1.getClass());
 342
 343         // BEGIN:Calendar_Test_Dimmer:0%:abc
 344         cmd2 = cmdTags.get(2).getCommand();
 345         assertNotNull(cmd2);
 346         assertEquals(PercentType.class, cmd2.getClass());
 347
 348         // BEGIN:Calendar_Test_Number:-12.3:abc
 349         cmd3 = cmdTags.get(3).getCommand();
 350         assertNotNull(cmd3);
 351         assertEquals(QuantityType.class, cmd3.getClass());
 352
 353         // BEGIN:Calendar_Test_Temperature:-12.3°C:abc
 354         cmd4 = cmdTags.get(4).getCommand();
 355         assertNotNull(cmd4);
 356         assertEquals(QuantityType.class, cmd4.getClass());
 357
 358         // BEGIN:Calendar_Test_Pressure:500mmHg:abc
 359         cmd5 = cmdTags.get(5).getCommand();
 360         assertNotNull(cmd5);
 361         assertEquals(QuantityType.class, cmd5.getClass());
 362
 363         // BEGIN:Calendar_Test_Speed:12300000mm/h:abc
 364         cmd6 = cmdTags.get(6).getCommand();
 365         assertNotNull(cmd6);
 366         assertEquals(QuantityType.class, cmd6.getClass());
 367
 368         // BEGIN:Calendar_Test_Player:REWIND:abc
 369         cmd7 = cmdTags.get(7).getCommand();
 370         assertNotNull(cmd7);
 371         assertEquals(RewindFastforwardType.class, cmd7.getClass());
 372
 373         // BEGIN:Calendar_Test_RollerShutter:100%:abc
 374         cmd8 = cmdTags.get(8).getCommand();
 375         assertNotNull(cmd8);
 376         assertEquals(PercentType.class, cmd8.getClass());
 377
 378         // BEGIN:Calendar_Test_String:Test Series #4:abc
 379         cmd9 = cmdTags.get(9).getCommand();
 380         assertNotNull(cmd9);
 381         assertEquals(StringType.class, cmd9.getClass());
 382
 383         // BEGIN:Calendar_Test_Switch:OFF:abc
 384         cmd10 = cmdTags.get(10).getCommand();
 385         assertNotNull(cmd10);
 386         assertEquals(OnOffType.class, cmd10.getClass());
 387
 388         // test tag syntax: Test Series #5
 389         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T20:25:00Z"),
 390                 Instant.parse("2020-01-28T20:35:00Z"));
 391         assertNotNull(events);
 392         assertEquals(1, events.size());
 393         cmdTags = events.get(0).commandTags;
 394         assertEquals(11, cmdTags.size());
 395
 396         // BEGIN:Calendar_Test_Color:240,100,100:abc
 397         cmd0 = cmdTags.get(0).getCommand();
 398         assertNotNull(cmd0);
 399         assertEquals(HSBType.class, cmd0.getClass());
 400
 401         // BEGIN:Calendar_Test_Contact:OPEN:abc
 402         cmd1 = cmdTags.get(1).getCommand();
 403         assertNotNull(cmd1);
 404         assertEquals(OpenClosedType.class, cmd1.getClass());
 405
 406         // BEGIN:Calendar_Test_Dimmer:50%:abc
 407         cmd2 = cmdTags.get(2).getCommand();
 408         assertNotNull(cmd2);
 409         assertEquals(PercentType.class, cmd2.getClass());
 410
 411         // BEGIN:Calendar_Test_Number:-0:abc
 412         cmd3 = cmdTags.get(3).getCommand();
 413         assertNotNull(cmd3);
 414         assertEquals(QuantityType.class, cmd3.getClass());
 415
 416         // BEGIN:Calendar_Test_Temperature:0K:abc
 417         cmd4 = cmdTags.get(4).getCommand();
 418         assertNotNull(cmd4);
 419         assertEquals(QuantityType.class, cmd4.getClass());
 420
 421         // BEGIN:Calendar_Test_Pressure:12.3hPa:abc
 422         cmd5 = cmdTags.get(5).getCommand();
 423         assertNotNull(cmd5);
 424         assertEquals(QuantityType.class, cmd5.getClass());
 425
 426         // BEGIN:Calendar_Test_Speed:12.3km/h:abc
 427         cmd6 = cmdTags.get(6).getCommand();
 428         assertNotNull(cmd6);
 429         assertEquals(QuantityType.class, cmd6.getClass());
 430
 431         // BEGIN:Calendar_Test_Player:PLAY:abc
 432         cmd7 = cmdTags.get(7).getCommand();
 433         assertNotNull(cmd7);
 434         assertEquals(PlayPauseType.class, cmd7.getClass());
 435
 436         // BEGIN:Calendar_Test_RollerShutter:50%:abc
 437         cmd8 = cmdTags.get(8).getCommand();
 438         assertNotNull(cmd8);
 439         assertEquals(PercentType.class, cmd8.getClass());
 440
 441         // BEGIN:Calendar_Test_String:Test Series #5:abc
 442         cmd9 = cmdTags.get(9).getCommand();
 443         assertNotNull(cmd9);
 444         assertEquals(StringType.class, cmd9.getClass());
 445
 446         // BEGIN:Calendar_Test_Switch:ON:abc
 447         cmd10 = cmdTags.get(10).getCommand();
 448         assertNotNull(cmd10);
 449         assertEquals(OnOffType.class, cmd10.getClass());
 450
 451         // test bad command tag syntax: Test Series #6
 452         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T20:40:00Z"),
 453                 Instant.parse("2020-01-28T20:50:00Z"));
 454         assertNotNull(events);
 455         assertEquals(1, events.size());
 456         cmdTags = events.get(0).commandTags;
 457         // Test Series #6 contains only "bad" command tags as follows..
 458
 459         // tags with wrong case prefix..
 460         // begin
 461         // Begin
 462         // BEGIn
 463
 464         // tags that are missing ":" field delimiters..
 465         // BEGIN
 466
 467         // tags with too few field delimiters..
 468         // BEGIN:www
 469
 470         // tags with too many field delimiters..
 471         // BEGIN:www:xxx:yyy:zzz
 472
 473         // tags with an invalid prefix..
 474         // BEGINX:xxx:yyy:zzz
 475         // ENDX:xxx:yyy:zzz
 476         // BEGIN :xxx:yyy:zzz
 477         // BEGIN :xxx:yyy:zzz
 478
 479         // tags with an empty Item Name
 480         // BEGIN::yyy:zzz
 481         // BEGIN: :yyy:zzz
 482         // BEGIN: :yyy:zzz
 483
 484         // tags with bad Item Name
 485         // BEGIN:!:yyy:zzz
 486         // BEGIN:@:yyy:zzz
 487         // BEGIN:£:yyy:zzz
 488
 489         // tags with an empty Target State value
 490         // BEGIN:xxx::zzz
 491         // BEGIN:xxx: :zzz
 492         // BEGIN:xxx: :zzz
 493
 494         // Note: All of the above tags must be rejected! => Assert cmdTags.size() == 0 !
 495
 496         assertEquals(0, cmdTags.size());
 497
 498         // test HTML command tag syntax: Test Series #7
 499         events = calendar3.getJustBegunEvents(Instant.parse("2020-01-28T20:55:00Z"),
 500                 Instant.parse("2020-01-28T21:05:00Z"));
 501         assertNotNull(events);
 502         assertEquals(1, events.size());
 503         cmdTags = events.get(0).commandTags;
 504         assertEquals(8, cmdTags.size());
 505
 506         // <p>BEGIN:Calendar_Test_Temperature:12.3°C:abc</p>
 507         cmd0 = cmdTags.get(0).getCommand();
 508         assertNotNull(cmd0);
 509         assertEquals(QuantityType.class, cmd0.getClass());
 510
 511         // <p>END:Calendar_Test_Temperature:23.4°C:abc</p>
 512         cmd1 = cmdTags.get(1).getCommand();
 513         assertNotNull(cmd1);
 514         assertEquals(QuantityType.class, cmd1.getClass());
 515
 516         // <p>BEGIN:Calendar_Test_Switch:ON:abc</p>
 517         cmd2 = cmdTags.get(2).getCommand();
 518         assertNotNull(cmd2);
 519         assertEquals(OnOffType.class, cmd2.getClass());
 520
 521         // <p>END:Calendar_Test_Switch:OFF:abc</p>
 522         cmd3 = cmdTags.get(3).getCommand();
 523         assertNotNull(cmd3);
 524         assertEquals(OnOffType.class, cmd3.getClass());
 525
 526         // <p>BEGIN:Calendar_Test_String:the quick:abc</p>
 527         cmd4 = cmdTags.get(4).getCommand();
 528         assertNotNull(cmd4);
 529         assertEquals(StringType.class, cmd4.getClass());
 530
 531         // <p>END:Calendar_Test_String:brown fox:abc</p>
 532         cmd5 = cmdTags.get(5).getCommand();
 533         assertNotNull(cmd5);
 534         assertEquals(StringType.class, cmd5.getClass());
 535
 536         // </p><p>BEGIN:Calendar_Test_Number:12.3:abc</p>
 537         cmd6 = cmdTags.get(6).getCommand();
 538         assertNotNull(cmd6);
 539         assertEquals(QuantityType.class, cmd6.getClass());
 540
 541         // <p>END:Calendar_Test_Number:23.4:abc</p>
 542         cmd7 = cmdTags.get(7).getCommand();
 543         assertNotNull(cmd7);
 544         assertEquals(QuantityType.class, cmd7.getClass());
 545     }
 546
 547     @SuppressWarnings("null")
 548     @Test
 549     public void testGetFilteredEventsBetween() {
 550         Event[] expectedFilteredEvents1 = new Event[] {
 551                 new Event("Test Series in UTC", Instant.parse("2019-09-12T09:05:00Z"),
 552                         Instant.parse("2019-09-12T09:10:00Z"), ""),
 553                 new Event("Test Event in UTC+2", Instant.parse("2019-09-14T08:00:00Z"),
 554                         Instant.parse("2019-09-14T09:00:00Z"), "") };
 555         List<Event> realFilteredEvents1 = calendar.getFilteredEventsBetween(Instant.parse("2019-09-12T06:00:00Z"),
 556                 Instant.parse("2019-09-15T06:00:00Z"), null, 3);
 557         assertArrayEquals(expectedFilteredEvents1, realFilteredEvents1.toArray(new Event[0]));
 558
 559         Event[] expectedFilteredEvents2 = new Event[] {
 560                 new Event("Evt", Instant.parse("2019-11-10T10:00:00Z"), Instant.parse("2019-11-10T11:45:00Z"), ""),
 561                 new Event("Evt", Instant.parse("2019-11-17T10:00:00Z"), Instant.parse("2019-11-17T11:45:00Z"), ""),
 562                 new Event("Evt", Instant.parse("2019-12-01T10:00:00Z"), Instant.parse("2019-12-01T11:45:00Z"), "") };
 563         List<Event> realFilteredEvents2 = calendar2.getFilteredEventsBetween(Instant.parse("2019-11-08T06:00:00Z"),
 564                 Instant.parse("2019-12-31T06:00:00Z"), null, 3);
 565         assertArrayEquals(expectedFilteredEvents2, realFilteredEvents2.toArray(new Event[] {}));
 566
 567         Event[] expectedFilteredEvents3 = new Event[] { new Event("Test Event in UTC+2",
 568                 Instant.parse("2019-09-14T08:00:00Z"), Instant.parse("2019-09-14T09:00:00Z"), "") };
 569         List<Event> realFilteredEvents3 = calendar.getFilteredEventsBetween(Instant.parse("2019-09-12T06:00:00Z"),
 570                 Instant.parse("2019-09-15T06:00:00Z"),
 571                 new EventTextFilter(EventTextFilter.Field.SUMMARY, "utc+2", EventTextFilter.Type.TEXT), 3);
 572         assertArrayEquals(expectedFilteredEvents3, realFilteredEvents3.toArray(new Event[] {}));
 573
 574         Event[] expectedFilteredEvents4 = new Event[] { new Event("Test Series in UTC",
 575                 Instant.parse("2019-09-12T09:05:00Z"), Instant.parse("2019-09-12T09:10:00Z"), "") };
 576         List<Event> realFilteredEvents4 = calendar.getFilteredEventsBetween(Instant.parse("2019-09-12T06:00:00Z"),
 577                 Instant.parse("2019-09-15T06:00:00Z"),
 578                 new EventTextFilter(EventTextFilter.Field.SUMMARY, ".*UTC$", EventTextFilter.Type.REGEX), 3);
 579         assertArrayEquals(expectedFilteredEvents4, realFilteredEvents4.toArray(new Event[] {}));
 580
 581         List<Event> realFilteredEvents5 = calendar.getFilteredEventsBetween(Instant.parse("2019-09-15T06:00:00Z"),
 582                 Instant.parse("2019-09-12T06:00:00Z"), null, 3);
 583         assertEquals(0, realFilteredEvents5.size());
 584
 585         List<Event> realFilteredEvents6 = calendar.getFilteredEventsBetween(Instant.parse("2019-09-15T06:00:00Z"),
 586                 Instant.parse("2019-12-31T00:00:00Z"), null, 3);
 587         assertEquals(0, realFilteredEvents6.size());
 588     }
 589 }