android/aitt/src/test/java/com/samsung/android/aitt/AittUnitTest.java

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.samsung.android.aitt;
  17
  18 import static org.junit.Assert.assertEquals;
  19 import static org.junit.Assert.assertNotNull;
  20 import static org.junit.Assert.assertThrows;
  21 import static org.junit.Assert.fail;
  22 import static org.mockito.Mockito.mock;
  23
  24 import android.content.Context;
  25
  26 import com.google.flatbuffers.FlexBuffersBuilder;
  27 import com.samsung.android.aitt.internal.Definitions;
  28
  29 import org.junit.Before;
  30 import org.junit.Test;
  31 import org.junit.runner.RunWith;
  32 import org.mockito.Mock;
  33 import org.robolectric.RobolectricTestRunner;
  34 import org.robolectric.annotation.Config;
  35
  36 import java.lang.reflect.Method;
  37 import java.nio.ByteBuffer;
  38 import java.nio.charset.StandardCharsets;
  39 import java.util.EnumSet;
  40
  41 @RunWith(RobolectricTestRunner.class)
  42 @Config(shadows = ShadowJniInterface.class)
  43 public class AittUnitTest {
  44     @Mock
  45     private final Context appContext = mock(Context.class);
  46
  47     private static final int DISCOVERY_MESSAGES_COUNT = 6;
  48     private final String brokerIp = "192.168.0.1";
  49     private final int port = 1803;
  50     private final String topic = "aitt/test";
  51     private final String message = "test message";
  52     private final String aittId = "aitt";
  53
  54     ShadowJniInterface shadowJniInterface = new ShadowJniInterface();
  55
  56     private Method messageCallbackMethod;
  57
  58     @Before
  59     public void initialize() {
  60         try {
  61             messageCallbackMethod = Aitt.class.getDeclaredMethod("messageCallback", String.class, byte[].class);
  62             messageCallbackMethod.setAccessible(true);
  63         } catch (Exception e) {
  64             fail("Failed to Initialize " + e);
  65         }
  66     }
  67
  68     private byte[] createDiscoveryMessage(int count) {
  69         int start;
  70         FlexBuffersBuilder builder = new FlexBuffersBuilder(ByteBuffer.allocate(512));
  71         start = builder.startMap();
  72         switch (count) {
  73             case 1:
  74                 /*
  75                  *           {
  76                  *             "status": "connected",
  77                  *             "host": "127.0.0.1",
  78                  *             "aitt/topic1": {
  79                  *                "protocol": TCP,
  80                  *                "port": 1000,
  81                  *             }
  82                  *            }
  83                  */
  84                 builder.putString("status", Definitions.JOIN_NETWORK);
  85                 builder.putString("host", Definitions.AITT_LOCALHOST);
  86                 int secondStart = builder.startMap();
  87                 builder.putInt("port", 1000);
  88                 builder.putInt("protocol", Aitt.Protocol.TCP.getValue());
  89                 builder.endMap("aitt/topic1", secondStart);
  90                 break;
  91             case 2:
  92                 /*
  93                  *           {
  94                  *             "status": "connected",
  95                  *             "host": "127.0.0.2",
  96                  *             "aitt/topic1": {
  97                  *                "protocol": MQTT,
  98                  *                "port": 2000,
  99                  *             }
 100                  *            }
 101                  */
 102                 builder.putString("status", Definitions.JOIN_NETWORK);
 103                 builder.putString("host", "127.0.0.2");
 104                 secondStart = builder.startMap();
 105                 builder.putInt("port", 2000);
 106                 builder.putInt("protocol", Aitt.Protocol.MQTT.getValue());
 107                 builder.endMap("aitt/topic1", secondStart);
 108                 break;
 109             case 3:
 110                 /*
 111                  *           {
 112                  *             "status": "connected",
 113                  *             "host": "127.0.0.1",
 114                  *             "aitt/topic2": {
 115                  *                "protocol": MQTT,
 116                  *                "port": 2000,
 117                  *             }
 118                  *            }
 119                  */
 120                 builder.putString("status", Definitions.JOIN_NETWORK);
 121                 builder.putString("host", Definitions.AITT_LOCALHOST);
 122                 secondStart = builder.startMap();
 123                 builder.putInt("port", 2000);
 124                 builder.putInt("protocol", Aitt.Protocol.MQTT.getValue());
 125                 builder.endMap("aitt/topic2", secondStart);
 126                 break;
 127             case 4:
 128                 /*
 129                  *           {
 130                  *             "status": "connected",
 131                  *             "host": "127.0.0.1",
 132                  *             "aitt/topic2": {
 133                  *                "protocol": TCP,
 134                  *                "port": 4000,
 135                  *             }
 136                  *            }
 137                  */
 138                 builder.putString("status", Definitions.JOIN_NETWORK);
 139                 builder.putString("host", Definitions.AITT_LOCALHOST);
 140                 secondStart = builder.startMap();
 141                 builder.putInt("port", 4000);
 142                 builder.putInt("protocol", Aitt.Protocol.TCP.getValue());
 143                 builder.endMap("aitt/topic2", secondStart);
 144                 break;
 145             case 5:
 146                 /*
 147                  *           {
 148                  *             "status": "connected",
 149                  *             "host": "127.0.0.1",
 150                  *             "aitt/topic2": {
 151                  *                "protocol": WEBRTC,
 152                  *                "port": 2000,
 153                  *             }
 154                  *            }
 155                  */
 156                 builder.putString("status", Definitions.JOIN_NETWORK);
 157                 builder.putString("host", Definitions.AITT_LOCALHOST);
 158                 secondStart = builder.startMap();
 159                 builder.putInt("port", 2000);
 160                 builder.putInt("protocol", Aitt.Protocol.WEBRTC.getValue());
 161                 builder.endMap("aitt/topic2", secondStart);
 162                 break;
 163             case 6:
 164                 /*
 165                  *           {
 166                  *             "status": "disconnected",
 167                  *             "host": "127.0.0.1",
 168                  *             "aitt/topic1": {
 169                  *                "protocol": TCP,
 170                  *                "port": 1000,
 171                  *             }
 172                  *            }
 173                  */
 174                 builder.putString("status", Definitions.WILL_LEAVE_NETWORK);
 175                 builder.putString("host", Definitions.AITT_LOCALHOST);
 176                 secondStart = builder.startMap();
 177                 builder.putInt("port", 1000);
 178                 builder.putInt("protocol", Aitt.Protocol.TCP.getValue());
 179                 builder.endMap("aitt/topic1", secondStart);
 180                 break;
 181             default:
 182                 return null;
 183         }
 184         builder.endMap(null, start);
 185         ByteBuffer bb = builder.finish();
 186         byte[] array = new byte[bb.remaining()];
 187         bb.get(array, 0, array.length);
 188         return array;
 189     }
 190
 191     @Test
 192     public void testAittConstructor_P() {
 193         String id = "aitt";
 194         try {
 195             shadowJniInterface.setInitReturn(true);
 196             Aitt aitt = new Aitt(appContext, id);
 197             assertNotNull("Aitt Instance not null", aitt);
 198         } catch (Exception e) {
 199             fail("Failed testAittConstructor " + e);
 200         }
 201     }
 202
 203     @Test(expected = IllegalArgumentException.class)
 204     public void testInitializeInvalidId_N() {
 205         String _id = "";
 206         try {
 207             shadowJniInterface.setInitReturn(true);
 208             Aitt aitt = new Aitt(appContext, _id);
 209             aitt.close();
 210         } catch (InstantiationException e) {
 211             fail("Error during testInitializeInvalidId" + e);
 212         }
 213     }
 214
 215     @Test(expected = IllegalArgumentException.class)
 216     public void testInitializeInvalidIp_N() {
 217         String ip = "";
 218         try {
 219             shadowJniInterface.setInitReturn(true);
 220             Aitt aitt = new Aitt(appContext, aittId, ip, false);
 221             aitt.close();
 222         } catch (InstantiationException e) {
 223             fail("Error during testInitializeInvalidIp" + e);
 224         }
 225     }
 226
 227     @Test(expected = IllegalArgumentException.class)
 228     public void testInitializeInvalidContext_N() {
 229         String _id = "";
 230         try {
 231             shadowJniInterface.setInitReturn(true);
 232             Aitt aitt = new Aitt(null, _id);
 233             aitt.close();
 234         } catch (InstantiationException e) {
 235             fail("Error during testInitializeInvalidContext" + e);
 236         }
 237     }
 238
 239     @Test(expected = InstantiationException.class)
 240     public void testConstructorFail_N() throws InstantiationException {
 241         shadowJniInterface.setInitReturn(false);
 242         String id = "aitt";
 243         Aitt aitt = new Aitt(appContext, id);
 244         aitt.close();
 245     }
 246
 247     @Test
 248     public void testConnect_P() {
 249         try {
 250             shadowJniInterface.setInitReturn(true);
 251             Aitt aitt = new Aitt(appContext, aittId);
 252
 253             assertNotNull("Aitt Instance not null", aitt);
 254             aitt.connect(brokerIp, port);
 255
 256             aitt.close();
 257         } catch (Exception e) {
 258             fail("Failed testConnect " + e);
 259         }
 260     }
 261
 262     @Test
 263     public void testConnectWithoutIP_P() {
 264         try {
 265             shadowJniInterface.setInitReturn(true);
 266             Aitt aitt = new Aitt(appContext, aittId);
 267
 268             assertNotNull("Aitt Instance not null", aitt);
 269             aitt.connect(null);
 270
 271             aitt.close();
 272         } catch (Exception e) {
 273             fail("Failed testConnectWithoutIP " + e);
 274         }
 275     }
 276
 277     @Test
 278     public void testDisconnect_P() {
 279         try {
 280             shadowJniInterface.setInitReturn(true);
 281             Aitt aitt = new Aitt(appContext, aittId);
 282
 283             assertNotNull("Aitt Instance not null", aitt);
 284             aitt.connect(brokerIp, port);
 285
 286             aitt.disconnect();
 287         } catch (Exception e) {
 288             fail("Failed testDisconnect " + e);
 289         }
 290     }
 291
 292     @Test
 293     public void testPublishMqtt_P() {
 294         try {
 295             shadowJniInterface.setInitReturn(true);
 296             Aitt aitt = new Aitt(appContext, aittId);
 297
 298             assertNotNull("Aitt Instance not null", aitt);
 299             aitt.connect(brokerIp, port);
 300
 301             byte[] payload = message.getBytes();
 302             aitt.publish(topic, payload);
 303
 304             aitt.disconnect();
 305         } catch (Exception e) {
 306             fail("Failed testPublishMqtt " + e);
 307         }
 308     }
 309
 310     @Test
 311     public void testPublishMqttInvalidTopic_N() {
 312         try {
 313             shadowJniInterface.setInitReturn(true);
 314             Aitt aitt = new Aitt(appContext, aittId);
 315             aitt.connect(brokerIp, port);
 316             String _topic = "";
 317             byte[] payload = message.getBytes();
 318
 319             assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload));
 320
 321             aitt.disconnect();
 322         } catch (Exception e) {
 323             fail("Failed testPublishMqttInvalidTopic" + e);
 324         }
 325     }
 326
 327     @Test
 328     public void testPublishWebRTC_P() {
 329         try {
 330             shadowJniInterface.setInitReturn(true);
 331             Aitt aitt = new Aitt(appContext, aittId);
 332
 333             assertNotNull("Aitt Instance not null", aitt);
 334             aitt.connect(brokerIp, port);
 335
 336             byte[] payload = message.getBytes();
 337             aitt.publish(topic, payload, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE, false);
 338
 339             aitt.disconnect();
 340         } catch (Exception e) {
 341             fail("Failed testPublishWebRTC " + e);
 342         }
 343     }
 344
 345     @Test
 346     public void testPublishWebRTCInvalidTopic_N() {
 347         try {
 348             shadowJniInterface.setInitReturn(true);
 349             Aitt aitt = new Aitt(appContext, aittId);
 350             aitt.connect(brokerIp, port);
 351             String _topic = "";
 352             byte[] payload = message.getBytes();
 353
 354             assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE, false));
 355
 356             aitt.disconnect();
 357         } catch (Exception e) {
 358             fail("Failed testPublishWebRTCInvalidTopic" + e);
 359         }
 360     }
 361
 362     @Test
 363     public void testPublishIpc_P() {
 364         try {
 365             shadowJniInterface.setInitReturn(true);
 366             Aitt aitt = new Aitt(appContext, aittId);
 367
 368             assertNotNull("Aitt Instance not null", aitt);
 369             aitt.connect(brokerIp, port);
 370
 371             byte[] payload = message.getBytes();
 372             aitt.publish(topic, payload, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE, false);
 373
 374             aitt.disconnect();
 375         } catch (Exception e) {
 376             fail("Failed testPublishIpc " + e);
 377         }
 378     }
 379
 380     @Test
 381     public void testPublishIpcInvalidTopic_N() {
 382         try {
 383             shadowJniInterface.setInitReturn(true);
 384             Aitt aitt = new Aitt(appContext, aittId);
 385             aitt.connect(brokerIp, port);
 386             String _topic = "";
 387             byte[] payload = message.getBytes();
 388
 389             assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE, false));
 390
 391             aitt.disconnect();
 392         } catch (Exception e) {
 393             fail("Failed testPublishIpcInvalidTopic" + e);
 394         }
 395     }
 396
 397     @Test
 398     public void testPublishAnyProtocol_P() {
 399         try {
 400             shadowJniInterface.setInitReturn(true);
 401             Aitt aitt = new Aitt(appContext, aittId);
 402
 403             assertNotNull("Aitt Instance not null", aitt);
 404             aitt.connect(brokerIp, port);
 405
 406             byte[] payload = message.getBytes();
 407             aitt.publish(topic, payload, Aitt.Protocol.TCP, Aitt.QoS.AT_LEAST_ONCE, false);
 408
 409             aitt.disconnect();
 410         } catch (Exception e) {
 411             fail("Failed testPublishAnyProtocol " + e);
 412         }
 413     }
 414
 415     @Test
 416     public void testPublishAnyProtocolInvalidTopic_N() {
 417         try {
 418             shadowJniInterface.setInitReturn(true);
 419             Aitt aitt = new Aitt(appContext, aittId);
 420             aitt.connect(brokerIp, port);
 421             String _topic = "";
 422             byte[] payload = message.getBytes();
 423
 424             assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, Aitt.Protocol.TCP, Aitt.QoS.AT_LEAST_ONCE, false));
 425
 426             aitt.disconnect();
 427         } catch (Exception e) {
 428             fail("Failed testPublishAnyProtocolInvalidTopic" + e);
 429         }
 430     }
 431
 432     @Test
 433     public void testPublishProtocolSet_P() {
 434         try {
 435             shadowJniInterface.setInitReturn(true);
 436             Aitt aitt = new Aitt(appContext, aittId);
 437
 438             assertNotNull("Aitt Instance not null", aitt);
 439             aitt.connect(brokerIp, port);
 440
 441             byte[] payload = message.getBytes();
 442             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
 443             aitt.publish(topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false);
 444
 445             aitt.disconnect();
 446         } catch (Exception e) {
 447             fail("Failed testPublishProtocolSet " + e);
 448         }
 449     }
 450
 451     @Test
 452     public void testPublishProtocolSetInvalidTopic_N() {
 453         try {
 454             shadowJniInterface.setInitReturn(true);
 455             Aitt aitt = new Aitt(appContext, aittId);
 456
 457             assertNotNull("Aitt Instance not null", aitt);
 458             aitt.connect(brokerIp, port);
 459             String _topic = "";
 460             byte[] payload = message.getBytes();
 461             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
 462
 463             assertThrows(IllegalArgumentException.class, () -> aitt.publish(_topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false));
 464
 465             aitt.disconnect();
 466         } catch (Exception e) {
 467             fail("Failed testPublishProtocolSetInvalidTopic " + e);
 468         }
 469     }
 470
 471     @Test
 472     public void testPublishInvalidProtocol_N() {
 473         try {
 474             shadowJniInterface.setInitReturn(true);
 475             Aitt aitt = new Aitt(appContext, aittId);
 476             aitt.connect(brokerIp, port);
 477             byte[] payload = message.getBytes();
 478             EnumSet<Aitt.Protocol> protocols = EnumSet.noneOf(Aitt.Protocol.class);
 479
 480             assertThrows(IllegalArgumentException.class, () -> aitt.publish(topic, payload, protocols, Aitt.QoS.AT_MOST_ONCE, false));
 481
 482             aitt.disconnect();
 483         } catch (Exception e) {
 484             fail("Failed testPublishInvalidProtocol" + e);
 485         }
 486     }
 487
 488     @Test
 489     public void testSubscribeMqtt_P() {
 490         try {
 491             shadowJniInterface.setInitReturn(true);
 492             Aitt aitt = new Aitt(appContext, aittId);
 493
 494             assertNotNull("Aitt Instance not null", aitt);
 495             aitt.connect(brokerIp, port);
 496
 497             aitt.subscribe(topic, message -> {
 498             });
 499
 500             aitt.disconnect();
 501         } catch (Exception e) {
 502             fail("Failed testSubscribeMqtt " + e);
 503         }
 504     }
 505
 506     @Test
 507     public void testSubscribeMqttInvalidTopic_N() {
 508         try {
 509             shadowJniInterface.setInitReturn(true);
 510             Aitt aitt = new Aitt(appContext, aittId);
 511             aitt.connect(brokerIp, port);
 512
 513             String _topic = "";
 514
 515             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
 516             }));
 517
 518             aitt.disconnect();
 519         } catch (Exception e) {
 520             fail("Failed testSubscribeMqttInvalidTopic " + e);
 521         }
 522     }
 523
 524     @Test
 525     public void testSubscribeMqttInvalidCallback_N() {
 526         try {
 527             shadowJniInterface.setInitReturn(true);
 528             Aitt aitt = new Aitt(appContext, aittId);
 529
 530             aitt.connect(brokerIp, port);
 531
 532             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null));
 533
 534             aitt.disconnect();
 535         } catch (Exception e) {
 536             fail("Failed testSubscribeMqttInvalidCallback " + e);
 537         }
 538     }
 539
 540     @Test
 541     public void testSubscribeTCP_P() {
 542         try {
 543             shadowJniInterface.setInitReturn(true);
 544             Aitt aitt = new Aitt(appContext, aittId);
 545
 546             assertNotNull("Aitt Instance not null", aitt);
 547             aitt.connect(brokerIp, port);
 548
 549             aitt.subscribe(topic, message -> {
 550             }, Aitt.Protocol.TCP);
 551
 552             aitt.disconnect();
 553         } catch (Exception e) {
 554             fail("Failed testSubscribeTCP " + e);
 555         }
 556     }
 557
 558     @Test
 559     public void testSubscribeTcpInvalidTopic_N() {
 560         try {
 561             shadowJniInterface.setInitReturn(true);
 562             Aitt aitt = new Aitt(appContext, aittId);
 563             aitt.connect(brokerIp, port);
 564
 565             String _topic = "";
 566
 567             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
 568             }, Aitt.Protocol.TCP));
 569
 570             aitt.disconnect();
 571         } catch (Exception e) {
 572             fail("Failed testSubscribeTcpInvalidTopic " + e);
 573         }
 574     }
 575
 576     @Test
 577     public void testSubscribeTcpInvalidCallback_N() {
 578         try {
 579             shadowJniInterface.setInitReturn(true);
 580             Aitt aitt = new Aitt(appContext, aittId);
 581
 582             aitt.connect(brokerIp, port);
 583
 584             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, Aitt.Protocol.TCP));
 585
 586             aitt.disconnect();
 587         } catch (Exception e) {
 588             fail("Failed testSubscribeTcpInvalidCallback " + e);
 589         }
 590     }
 591
 592     @Test
 593     public void testSubscribeWebRTC_P() {
 594         try {
 595             shadowJniInterface.setInitReturn(true);
 596             Aitt aitt = new Aitt(appContext, aittId);
 597
 598             assertNotNull("Aitt Instance not null", aitt);
 599             aitt.connect(brokerIp, port);
 600
 601             aitt.subscribe(topic, message -> {
 602             }, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE);
 603
 604             aitt.disconnect();
 605         } catch (Exception e) {
 606             fail("Failed testSubscribeWebRTC " + e);
 607         }
 608     }
 609
 610     @Test
 611     public void testSubscribeWebRTCInvalidTopic_N() {
 612         try {
 613             shadowJniInterface.setInitReturn(true);
 614             Aitt aitt = new Aitt(appContext, aittId);
 615             aitt.connect(brokerIp, port);
 616
 617             String _topic = "";
 618
 619             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
 620             }, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE));
 621
 622             aitt.disconnect();
 623         } catch (Exception e) {
 624             fail("Failed testSubscribeWebRTCInvalidTopic " + e);
 625         }
 626     }
 627
 628     @Test
 629     public void testSubscribeWebRTCInvalidCallback_N() {
 630         try {
 631             shadowJniInterface.setInitReturn(true);
 632             Aitt aitt = new Aitt(appContext, aittId);
 633
 634             aitt.connect(brokerIp, port);
 635
 636             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, Aitt.Protocol.WEBRTC, Aitt.QoS.AT_MOST_ONCE));
 637
 638             aitt.disconnect();
 639         } catch (Exception e) {
 640             fail("Failed testSubscribeWebRTCInvalidCallback " + e);
 641         }
 642     }
 643
 644     @Test
 645     public void testSubscribeIpc_P() {
 646         try {
 647             shadowJniInterface.setInitReturn(true);
 648             Aitt aitt = new Aitt(appContext, aittId);
 649
 650             assertNotNull("Aitt Instance not null", aitt);
 651             aitt.connect(brokerIp, port);
 652
 653             aitt.subscribe(topic, message -> {
 654             }, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE);
 655
 656             aitt.disconnect();
 657         } catch (Exception e) {
 658             fail("Failed testSubscribeIpc " + e);
 659         }
 660     }
 661
 662     @Test
 663     public void testSubscribeIpcInvalidTopic_N() {
 664         try {
 665             shadowJniInterface.setInitReturn(true);
 666             Aitt aitt = new Aitt(appContext, aittId);
 667             aitt.connect(brokerIp, port);
 668
 669             String _topic = "";
 670
 671             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
 672             }, Aitt.Protocol.IPC, Aitt.QoS.AT_MOST_ONCE));
 673
 674             aitt.disconnect();
 675         } catch (Exception e) {
 676             fail("Failed testSubscribeIpcInvalidTopic " + e);
 677         }
 678     }
 679
 680     @Test
 681     public void testSubscribeAnyProtocol_P() {
 682         try {
 683             shadowJniInterface.setInitReturn(true);
 684             Aitt aitt = new Aitt(appContext, aittId);
 685
 686             assertNotNull("Aitt Instance not null", aitt);
 687             aitt.connect(brokerIp, port);
 688
 689             aitt.subscribe(topic, message -> {
 690             }, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE);
 691
 692             aitt.disconnect();
 693         } catch (Exception e) {
 694             fail("Failed testSubscribeAnyProtocol " + e);
 695         }
 696     }
 697
 698     @Test
 699     public void testSubscribeAnyProtocolInvalidTopic_N() {
 700         try {
 701             shadowJniInterface.setInitReturn(true);
 702             Aitt aitt = new Aitt(appContext, aittId);
 703             aitt.connect(brokerIp, port);
 704
 705             String _topic = "";
 706
 707             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
 708             }, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE));
 709
 710             aitt.disconnect();
 711         } catch (Exception e) {
 712             fail("Failed testSubscribeAnyProtocolInvalidTopic " + e);
 713         }
 714     }
 715
 716     @Test
 717     public void testSubscribeAnyProtocolInvalidCallback_N() {
 718         try {
 719             shadowJniInterface.setInitReturn(true);
 720             Aitt aitt = new Aitt(appContext, aittId);
 721
 722             aitt.connect(brokerIp, port);
 723
 724             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, Aitt.Protocol.TCP, Aitt.QoS.AT_MOST_ONCE));
 725
 726             aitt.disconnect();
 727         } catch (Exception e) {
 728             fail("Failed testSubscribeAnyProtocolInvalidCallback " + e);
 729         }
 730     }
 731
 732     @Test
 733     public void testSubscribeInvalidProtocol_N() {
 734         try {
 735             shadowJniInterface.setInitReturn(true);
 736             Aitt aitt = new Aitt(appContext, aittId);
 737
 738             aitt.connect(brokerIp, port);
 739             EnumSet<Aitt.Protocol> protocols = EnumSet.noneOf(Aitt.Protocol.class);
 740
 741             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, message -> {
 742             }, protocols, Aitt.QoS.AT_MOST_ONCE));
 743
 744             aitt.disconnect();
 745         } catch (Exception e) {
 746             fail("Failed testSubscribeInvalidProtocol " + e);
 747         }
 748     }
 749
 750     @Test
 751     public void testSubscribeProtocolSet_P() {
 752         try {
 753             shadowJniInterface.setInitReturn(true);
 754             Aitt aitt = new Aitt(appContext, aittId);
 755
 756             assertNotNull("Aitt Instance not null", aitt);
 757             aitt.connect(brokerIp, port);
 758
 759             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
 760             aitt.subscribe(topic, message -> {
 761             }, protocols, Aitt.QoS.EXACTLY_ONCE);
 762
 763             aitt.disconnect();
 764         } catch (Exception e) {
 765             fail("Failed testSubscribeProtocolSet " + e);
 766         }
 767     }
 768
 769     @Test
 770     public void testSubscribeProtocolSetInvalidTopic_N() {
 771         try {
 772             shadowJniInterface.setInitReturn(true);
 773             Aitt aitt = new Aitt(appContext, aittId);
 774             aitt.connect(brokerIp, port);
 775
 776             String _topic = "";
 777             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
 778             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(_topic, message -> {
 779             }, protocols, Aitt.QoS.EXACTLY_ONCE));
 780
 781             aitt.disconnect();
 782         } catch (Exception e) {
 783             fail("Failed testSubscribeProtocolSetInvalidTopic " + e);
 784         }
 785     }
 786
 787     @Test
 788     public void testSubscribeProtocolSetInvalidCallback_N() {
 789         try {
 790             shadowJniInterface.setInitReturn(true);
 791             Aitt aitt = new Aitt(appContext, aittId);
 792
 793             aitt.connect(brokerIp, port);
 794             EnumSet<Aitt.Protocol> protocols = EnumSet.of(Aitt.Protocol.MQTT, Aitt.Protocol.TCP);
 795             assertThrows(IllegalArgumentException.class, () -> aitt.subscribe(topic, null, protocols, Aitt.QoS.AT_MOST_ONCE));
 796
 797             aitt.disconnect();
 798         } catch (Exception e) {
 799             fail("Failed testSubscribeProtocolSetInvalidCallback " + e);
 800         }
 801     }
 802
 803     @Test
 804     public void testUnsubscribe_P() {
 805         try {
 806             shadowJniInterface.setInitReturn(true);
 807             Aitt aitt = new Aitt(appContext, aittId);
 808
 809             assertNotNull("Aitt Instance not null", aitt);
 810             aitt.connect(brokerIp, port);
 811
 812             aitt.subscribe(topic, message -> {
 813             });
 814
 815             aitt.unsubscribe(topic);
 816             aitt.disconnect();
 817         } catch (Exception e) {
 818             fail("Failed testUnsubscribe " + e);
 819         }
 820     }
 821
 822     @Test
 823     public void testUnsubscribeInvalidTopic_N() {
 824         try {
 825             shadowJniInterface.setInitReturn(true);
 826             Aitt aitt = new Aitt(appContext, aittId);
 827
 828             aitt.connect(brokerIp, port);
 829             String _topic = "";
 830
 831             assertThrows(IllegalArgumentException.class, () -> aitt.unsubscribe(_topic));
 832
 833             aitt.disconnect();
 834         } catch (Exception e) {
 835             fail("Failed testUnsubscribeInvalidTopic " + e);
 836         }
 837     }
 838
 839     @Test
 840     public void testSetConnectionCallback_P() {
 841         try {
 842             shadowJniInterface.setInitReturn(true);
 843             Aitt aitt = new Aitt(appContext, aittId);
 844
 845             assertNotNull("Aitt Instance not null", aitt);
 846             aitt.setConnectionCallback(new Aitt.ConnectionCallback() {
 847                 @Override
 848                 public void onConnected() {
 849                 }
 850
 851                 @Override
 852                 public void onDisconnected() {
 853                 }
 854
 855                 @Override
 856                 public void onConnectionFailed() {
 857                 }
 858             });
 859             aitt.connect(brokerIp, port);
 860
 861             aitt.disconnect();
 862         } catch (Exception e) {
 863             fail("Failed testSetConnectionCallback " + e);
 864         }
 865     }
 866
 867     @Test
 868     public void testSetConnectionCallbackInvalidCallback_N() {
 869         try {
 870             shadowJniInterface.setInitReturn(true);
 871             Aitt aitt = new Aitt(appContext, aittId);
 872
 873             assertThrows(IllegalArgumentException.class, () -> aitt.setConnectionCallback(null));
 874
 875             aitt.connect(brokerIp, port);
 876             aitt.disconnect();
 877         } catch (Exception e) {
 878             fail("Failed testSetConnectionCallbackInvalidCallback " + e);
 879         }
 880     }
 881
 882     @Test
 883     public void testSubscribeMultipleCallbacks_P() {
 884         try {
 885             shadowJniInterface.setInitReturn(true);
 886             Aitt aitt = new Aitt(appContext, aittId);
 887
 888             assertNotNull("Aitt Instance not null", aitt);
 889             aitt.connect(brokerIp, port);
 890
 891             Aitt.SubscribeCallback callback1 = message -> {
 892             };
 893
 894             Aitt.SubscribeCallback callback2 = message -> {
 895             };
 896
 897             aitt.subscribe(topic, callback1);
 898             aitt.subscribe(topic, callback2);
 899
 900             aitt.disconnect();
 901         } catch (Exception e) {
 902             fail("Failed testSubscribeMultipleCallbacks " + e);
 903         }
 904     }
 905
 906     // The test covers different cases of updating the publish table
 907     @Test
 908     public void testDiscoveryMessageCallbackConnected_P() {
 909         try {
 910             shadowJniInterface.setInitReturn(true);
 911             Aitt aitt = new Aitt(appContext, aittId);
 912
 913             assertNotNull("Aitt Instance not null", aitt);
 914             aitt.connect(brokerIp, port);
 915
 916             int counter = 1;
 917             while (counter < DISCOVERY_MESSAGES_COUNT) {
 918                 byte[] discoveryMessage = createDiscoveryMessage(counter);
 919                 messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, discoveryMessage);
 920                 counter++;
 921             }
 922
 923             aitt.disconnect();
 924         } catch (Exception e) {
 925             fail("Failed testDiscoveryMessageCallback " + e);
 926         }
 927     }
 928
 929     @Test
 930     public void testDiscoveryMessageCallbackDisconnected_P() {
 931         try {
 932             shadowJniInterface.setInitReturn(true);
 933             Aitt aitt = new Aitt(appContext, aittId);
 934
 935             assertNotNull("Aitt Instance not null", aitt);
 936             aitt.connect(brokerIp, port);
 937
 938             int counter = 1;
 939             byte[] discoveryMessage = createDiscoveryMessage(counter);
 940             messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, discoveryMessage);
 941
 942             counter = 6;
 943             byte[] disconnectMessage = createDiscoveryMessage(counter);
 944             messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, disconnectMessage);
 945             aitt.disconnect();
 946         } catch (Exception e) {
 947             fail("Failed testDiscoveryMessageCallback " + e);
 948         }
 949     }
 950
 951     @Test
 952     public void testDiscoveryMessageCallbackEmptyPayload_N() {
 953         try {
 954             shadowJniInterface.setInitReturn(true);
 955             Aitt aitt = new Aitt(appContext, aittId);
 956
 957             assertNotNull("Aitt Instance not null", aitt);
 958             aitt.connect(brokerIp, port);
 959
 960             byte[] discoveryMessage = new byte[0];
 961             messageCallbackMethod.invoke(aitt, Definitions.JAVA_SPECIFIC_DISCOVERY_TOPIC, discoveryMessage);
 962
 963             aitt.disconnect();
 964         } catch (Exception e) {
 965             fail("Failed testDiscoveryMessageCallbackEmptyPayload " + e);
 966         }
 967     }
 968
 969     @Test
 970     public void testSubscribeCallbackVerifyTopic_P() {
 971         try {
 972             shadowJniInterface.setInitReturn(true);
 973             Aitt aitt = new Aitt(appContext, aittId);
 974             aitt.connect(brokerIp, port);
 975
 976             aitt.subscribe(topic, aittMessage -> {
 977                 String receivedTopic = aittMessage.getTopic();
 978                 assertEquals("Received topic and subscribed topic are equal", receivedTopic, topic);
 979             });
 980
 981             messageCallbackMethod.invoke(aitt, topic, message.getBytes(StandardCharsets.UTF_8));
 982
 983             aitt.disconnect();
 984         } catch (Exception e) {
 985             fail("Failed testSubscribeCallback " + e);
 986         }
 987     }
 988
 989     @Test
 990     public void testSubscribeCallbackVerifyPayload_P() {
 991         try {
 992             shadowJniInterface.setInitReturn(true);
 993             Aitt aitt = new Aitt(appContext, aittId);
 994             aitt.connect(brokerIp, port);
 995
 996             aitt.subscribe(topic, aittMessage -> {
 997                 String receivedMessage = new String(aittMessage.getPayload(), StandardCharsets.UTF_8);
 998                 assertEquals("Received message and sent message are equal", message, receivedMessage);
 999             });
1000
1001             messageCallbackMethod.invoke(aitt, topic, message.getBytes(StandardCharsets.UTF_8));
1002
1003             aitt.disconnect();
1004         } catch (Exception e) {
1005             fail("Failed testSubscribeCallback " + e);
1006         }
1007     }
1008 }