From 0245a5635e618f9cec7264a42490541dbd65aa2c Mon Sep 17 00:00:00 2001
From: Arif Burak Demiray <57103426+arifBurakDemiray@users.noreply.github.com>
Date: Fri, 10 Nov 2023 14:30:36 +0300
Subject: [PATCH] [Java] Add new device ID module tests add device ID type to
 scenario tests (#161)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat: new device id change callback

* feat: call after onDeviceId

* refactor: usage of device id changed in module device id

* feat: did changes

* feat: add device id type to scenario tests

* fix: tests

* revert: scenario changes

* feat: missing comments

* feat: new device id module calls to scenarioo device id tests

* feat: missing changelog

* fix: update existing tests

* fix: add check to callback

* refactor: remove unnecessary callback

* feat: test ccases

* fix: login and logout

* refactor: device id module

* fix: remove unnecessary params

* feat: new tests

* fix: rq access index

* feat: multiple device id check

* fix: test

* fix: device id change logic

* fix: device id callbacks

* fix: module events req

* fix: module event check and test cases comments

* fix: new ids

* fix: added missings tests

* feat: buggy test for device id change

* refactor: remove unsued

* fix: changed index of features

* fix: end any view

* feat: finish up tests

* misc

* fix: without merge not started session

* fix: add missing test cases

---------

Co-authored-by: Artūrs Kadiķis <kadikis.arturs@gmail.com>
---
 CHANGELOG.md                                  |   3 +-
 .../count/sdk/java/internal/CoreFeature.java  |   4 +-
 .../count/sdk/java/internal/ModuleBase.java   |  17 +-
 .../sdk/java/internal/ModuleDeviceIdCore.java |  55 +-
 .../count/sdk/java/internal/ModuleEvents.java |  46 +-
 .../sdk/java/internal/ModuleSessions.java     |  17 +-
 .../ly/count/sdk/java/internal/SDKCore.java   |  12 +-
 .../count/sdk/java/internal/SessionImpl.java  |   5 -
 .../java/internal/ModuleDeviceIdTests.java    | 571 +++++++++++++++++-
 .../internal/ModuleRemoteConfigTests.java     |   6 +-
 .../internal/ScenarioDeviceIdInitTests.java   |  18 +-
 ...enarioRemoteConfigDeviceIdChangeTests.java |   4 +-
 .../ly/count/sdk/java/internal/TestUtils.java |  41 +-
 13 files changed, 688 insertions(+), 111 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index efc5dfe90..f1d5a702f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,7 +14,8 @@
   * 'enableRemoteConfigAutomaticTriggers' to automatically download remote config values on init
   * 'remoteConfigRegisterGlobalCallback(RCDownloadCallback callback)' to register a remote config callback
 * Added the ability to set the user profile picture with an URL
-* Added to a way to get device id type by calling "Countly::deviceId::getType" via "instance()" call
+* Added the DeviceId interface. It is accessible through "Countly::instance()::deviceId()" call.
+* Added a way to get device id type by calling "Countly::deviceId::getType" via "instance()" call
 * The SDK now uses a different file for internal configuration. Old file will be deleted.
 
 * Fixed a bug where it was not possible to send a profile picture with binary data
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/CoreFeature.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/CoreFeature.java
index e832a112f..c921f3ec1 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/CoreFeature.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/CoreFeature.java
@@ -4,8 +4,8 @@
 import java.util.Map;
 
 public enum CoreFeature {
-    Sessions(1 << 1, ModuleSessions::new),
-    Events(1 << 2, ModuleEvents::new),
+    Events(1 << 1, ModuleEvents::new),
+    Sessions(1 << 2, ModuleSessions::new),
     Views(1 << 3, ModuleViews::new),
     CrashReporting(1 << 4, ModuleCrash::new),
     Location(1 << 5),
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleBase.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleBase.java
index f3a6a58fe..0b676ace4 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleBase.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleBase.java
@@ -1,11 +1,9 @@
 package ly.count.sdk.java.internal;
 
-import ly.count.sdk.java.Config;
 import ly.count.sdk.java.Session;
 
 /**
  * Created by artem on 05/01/2017.
- *
  * Contract:
  * <ul>
  *     <li>ModuleBase instances must provide empty constructor with no parameters.</li>
@@ -33,18 +31,6 @@ public void init(InternalConfig config) {
         internalConfig = config;
     }
 
-    /**
-     * Device ID has been acquired from the device id provider.
-     * Can be invoked multiple times throughout the ModuleBase lifecycle.
-     * Parameters can be instance equal (==), meaning that id haven't changed.
-     *
-     * @param config InternalConfig to run in
-     * @param deviceId deviceId valid from now on
-     * @param oldDeviceId deviceId valid previously if any
-     */
-    public void onDeviceId(InternalConfig config, Config.DID deviceId, Config.DID oldDeviceId) {
-    }
-
     /**
      * App users opted out of analytics, or the developer changed essential preferences.
      * Clear all module-related data, close any resources, and prepare to start from a clean sheet.
@@ -131,6 +117,9 @@ protected void initFinished(InternalConfig config) {
 
     /**
      * Called when the device id is changed.
+     *
+     * @param oldDeviceId old device id
+     * @param withMerge if the device id change is with merge or not
      */
     protected void deviceIdChanged(String oldDeviceId, boolean withMerge) {
 
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleDeviceIdCore.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleDeviceIdCore.java
index 15a83a41b..e2923eeae 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleDeviceIdCore.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleDeviceIdCore.java
@@ -81,7 +81,7 @@ public void initFinished(final InternalConfig config) {
                 L.d("[ModuleDeviceIdCore] initFinished, Got developer id [" + did + "]");
             } else {
                 // regular flow - acquire id using specified strategy
-                did = acquireId(config);
+                did = acquireId();
             }
 
             config.setDeviceId(did);
@@ -97,28 +97,16 @@ public void initFinished(final InternalConfig config) {
     public void deviceIdChanged(String oldDeviceId, boolean withMerge) {
         L.d("[ModuleDeviceIdCore] deviceIdChanged, oldDeviceId [" + oldDeviceId + "] withMerge [" + withMerge + "]");
         Config.DID deviceId = internalConfig.getDeviceId();
-        SessionImpl session = SDKCore.instance.getSession();
-
-        if (deviceId != null && oldDeviceId != null && !deviceId.id.equals(oldDeviceId)) {
-            // device id changed
-            if (session != null && session.isActive()) {
-                // end previous session
-                L.d("[ModuleDeviceIdCore] Ending session because device id was changed from [" + oldDeviceId + "]");
-                session.end(null, null, oldDeviceId);
-            }
-
-            // add device id change request
-            Request request = ModuleRequests.nonSessionRequest(internalConfig);
 
-            //if we are missing the device ID, add it
-            if (!request.params.has(Params.PARAM_DEVICE_ID)) {
-                request.params.add(Params.PARAM_DEVICE_ID, deviceId.id);
-            }
-            //add the old device ID every time
-            request.params.add(Params.PARAM_OLD_DEVICE_ID, oldDeviceId);
+        if (Utils.isEmptyOrNull(deviceId.id) || Utils.isEmptyOrNull(oldDeviceId)) {
+            L.w("[ModuleDeviceIdCore] deviceIdChanged, Empty id passed to changeDeviceId method");
+            return;
+        }
 
-            ModuleRequests.pushAsync(internalConfig, request);
-            SDKCore.instance.onSignal(internalConfig, SDKCore.Signal.DID.getIndex());
+        //if without merge then we should not send this request
+        if (withMerge) {
+            // add device id change request and add the old device ID every time
+            ModuleRequests.pushAsync(internalConfig, new Request(Params.PARAM_OLD_DEVICE_ID, oldDeviceId));
         }
     }
 
@@ -139,7 +127,7 @@ public void login(String id) {
      * - send corresponding request to server.
      */
     public void logout() {
-        Config.DID did = acquireId(internalConfig);
+        Config.DID did = acquireId();
         changeDeviceIdInternal(did.id, DeviceIdType.fromInt(did.strategy, L), false);
     }
 
@@ -163,18 +151,9 @@ protected void changeDeviceIdInternal(String id, DeviceIdType type, boolean with
             return;
         }
 
-        Config.DID did = new Config.DID(type.index, id);
         internalConfig.storageProvider.setDeviceIdType(type.name());
         internalConfig.storageProvider.setDeviceID(id);
-        internalConfig.setDeviceId(did);
-
-        if (!withMerge) {
-            SessionImpl session = SDKCore.instance.getSession();
-            if (session != null) {
-                L.d("[ModuleDeviceIdCore] changeDeviceIdInternal, Ending session because device id was unset from [" + old.id + "]");
-                session.end(null, null, old.id);
-            }
-        }
+        internalConfig.setDeviceId(new Config.DID(type.index, id));
 
         SDKCore.instance.notifyModulesDeviceIdChanged(old.id, withMerge);
     }
@@ -182,14 +161,12 @@ protected void changeDeviceIdInternal(String id, DeviceIdType type, boolean with
     /**
      * Gets id of the strategy supplied. In case strategy is not available, returns a fallback strategy.
      * In case strategy is available but id cannot be acquired right now, returns null.
-     *
-     * @param config InternalConfig to run in
      */
-    protected Config.DID acquireId(final InternalConfig config) {
-        L.i("[ModuleDeviceIdCore] acquireId, Acquiring device id of strategy [" + config.getDeviceIdStrategy() + "]");
+    protected Config.DID acquireId() {
+        L.i("[ModuleDeviceIdCore] acquireId, Acquiring device id of strategy [" + internalConfig.getDeviceIdStrategy() + "]");
         Config.DID did = null;
 
-        int index = config.getDeviceIdStrategy();
+        int index = internalConfig.getDeviceIdStrategy();
 
         while (index >= 0) {
             DeviceIdGenerator generator = generators.get(index);
@@ -197,7 +174,7 @@ protected Config.DID acquireId(final InternalConfig config) {
                 L.w("[ModuleDeviceIdCore] Device id strategy [" + index + "] is not available. Falling back to next one.");
                 index--;
             } else {
-                String id = generator.generate(config);
+                String id = generator.generate(internalConfig);
                 if (Utils.isNotEmpty(id)) {
                     did = new Config.DID(index, id);
                     break;
@@ -214,7 +191,7 @@ protected Config.DID acquireId(final InternalConfig config) {
             }
             L.d("[ModuleDeviceIdCore] acquireId, Got device id: " + did);
         } else {
-            L.i("[ModuleDeviceIdCore] acquireId, No device id of strategy [" + config.getDeviceIdStrategy() + "] is available yet");
+            L.i("[ModuleDeviceIdCore] acquireId, No device id of strategy [" + internalConfig.getDeviceIdStrategy() + "] is available yet");
         }
 
         return did;
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleEvents.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleEvents.java
index 36137665e..d49262e7f 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleEvents.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleEvents.java
@@ -1,14 +1,16 @@
 package ly.count.sdk.java.internal;
 
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 import ly.count.sdk.java.Countly;
+import ly.count.sdk.java.Session;
+import ly.count.sdk.java.View;
 
 public class ModuleEvents extends ModuleBase {
     protected EventQueue eventQueue = null;
-    final Map<String, EventImpl> timedEvents = new HashMap<>();
+    final Map<String, EventImpl> timedEvents = new ConcurrentHashMap<>();
     protected Events eventsInterface = null;
 
     @Override
@@ -22,7 +24,7 @@ public void init(InternalConfig config) {
 
     @Override
     protected void onTimer() {
-        addEventsToRequestQ();
+        addEventsToRequestQ(null);
     }
 
     @Override
@@ -30,6 +32,31 @@ public Boolean onRequest(Request request) {
         return true;
     }
 
+    @Override
+    public void deviceIdChanged(String oldDeviceId, boolean withMerge) {
+        super.deviceIdChanged(oldDeviceId, withMerge);
+        L.d("[ModuleEvents] deviceIdChanged: oldDeviceId = " + oldDeviceId + ", withMerge = " + withMerge);
+        if (!withMerge) {
+            for (Map.Entry<String, EventImpl> timedEventEntry : timedEvents.entrySet()) {
+                L.d("[ModuleEvents] deviceIdChanged, Ending timed event: [" + timedEventEntry.getKey() + "]");
+                endEventInternal(timedEventEntry.getKey(), timedEventEntry.getValue().segmentation, timedEventEntry.getValue().count, timedEventEntry.getValue().sum);
+            }
+
+            // this part is to end and record the current view if exists
+            Session session = Countly.session();
+            if ((session != null && session.isActive())) {
+                View currentView = ((SessionImpl) session).currentView;
+                if (currentView != null) {
+                    currentView.stop(true);
+                } else {
+                    Storage.pushAsync(internalConfig, ((SessionImpl) Countly.session()));
+                }
+            }
+
+            addEventsToRequestQ(oldDeviceId);
+        }
+    }
+
     @Override
     public void stop(InternalConfig config, final boolean clear) {
         super.stop(config, clear);
@@ -39,11 +66,18 @@ public void stop(InternalConfig config, final boolean clear) {
         }
     }
 
-    private synchronized void addEventsToRequestQ() {
+    private synchronized void addEventsToRequestQ(String deviceId) {
         L.d("[ModuleEvents] addEventsToRequestQ");
 
+        if (eventQueue.eventQueueMemoryCache.isEmpty()) {
+            L.d("[ModuleEvents] addEventsToRequestQ, eventQueueMemoryCache is empty, skipping");
+            return;
+        }
+
         Request request = new Request();
-        request.params.add("device_id", Countly.instance().getDeviceId());
+        if (deviceId != null) {
+            request.params.add("device_id", deviceId);
+        }
         request.params.arr("events").put(eventQueue.eventQueueMemoryCache).add();
         request.own(ModuleEvents.class);
 
@@ -93,7 +127,7 @@ private void addEventToQueue(EventImpl event) {
     private void checkEventQueueToSend(boolean forceSend) {
         L.d("[ModuleEvents] queue size:[" + eventQueue.eqSize() + "] || forceSend: " + forceSend);
         if (forceSend || (eventQueue.eqSize() >= internalConfig.getEventsBufferSize())) {
-            addEventsToRequestQ();
+            addEventsToRequestQ(null);
         }
     }
 
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleSessions.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleSessions.java
index 8188af06a..58977e5c1 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleSessions.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/ModuleSessions.java
@@ -60,12 +60,19 @@ public void stop(InternalConfig config, boolean clear) {
     /**
      * Handles one single case of device id change with auto sessions handling, see first {@code if} here:
      *
-     * @see ModuleDeviceIdCore#onDeviceId(InternalConfig, Config.DID, Config.DID)
+     * @see ModuleDeviceIdCore#deviceIdChanged(String, boolean)
      */
-    public void onDeviceId(final InternalConfig config, final Config.DID deviceId, final Config.DID oldDeviceId) {
-        L.d("[ModuleSessions] onDeviceId " + deviceId + ", old " + oldDeviceId);
-        if (deviceId != null && oldDeviceId != null && !deviceId.equals(oldDeviceId) && getSession() == null) {
-            session(config, null).begin();
+    @Override
+    public void deviceIdChanged(String oldDeviceId, boolean withMerge) {
+        Config.DID deviceId = internalConfig.getDeviceId();
+        L.d("[ModuleSessions] deviceIdChanged, " + deviceId + ", old " + oldDeviceId);
+        if (!withMerge && session != null && session.isActive()) {
+            L.d("[ModuleSessions] deviceIdChanged, Ending session because device id was unset from [" + oldDeviceId + "]");
+            session.end(null, null, oldDeviceId);
+        }
+        
+        if (deviceId != null && oldDeviceId != null && (session == null || !session.isActive()) && !withMerge) {
+            session(internalConfig, null).begin();
         }
     }
 
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/SDKCore.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/SDKCore.java
index 629208200..806030cbf 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/SDKCore.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/SDKCore.java
@@ -49,7 +49,7 @@ public SDKCore() {
     }
 
     protected Log L = null;
-    private static ModuleBase testDummyModule = null;//set during testing when trying to check the SDK's lifecycle
+    protected static ModuleBase testDummyModule = null;//set during testing when trying to check the SDK's lifecycle
 
     protected static void registerDefaultModuleMappings() {
         moduleMappings.put(CoreFeature.DeviceId.getIndex(), ModuleDeviceIdCore.class);
@@ -588,12 +588,14 @@ public void onCrash(final InternalConfig config, Throwable t, boolean fatal, Str
     }
 
     public void notifyModulesDeviceIdChanged(@Nullable String old, final boolean withMerge) {
-        L.d("[SDKCore] deviceIdChanged, newDeviceId:[" + config.getDeviceId() + "], oldDeviceId:[ " + old + "]");
+        L.d("[SDKCore] notifyModulesDeviceIdChanged, newDeviceId:[" + config.getDeviceId() + "], oldDeviceId:[ " + old + "]");
         Config.DID id = config.getDeviceId();
-        modules.forEach((feature, module) -> module.deviceIdChanged(old, withMerge));
-        if (id != null) {
-            user.id = id.id;
+        if (id.id.equals(old)) {
+            L.d("[SDKCore] notifyModulesDeviceIdChanged, newDeviceId is the same as oldDeviceId, skipping");
+            return;
         }
+        modules.forEach((feature, module) -> module.deviceIdChanged(old, withMerge));
+        user.id = id.id;
     }
 
     public void login(String id) {
diff --git a/sdk-java/src/main/java/ly/count/sdk/java/internal/SessionImpl.java b/sdk-java/src/main/java/ly/count/sdk/java/internal/SessionImpl.java
index 5fe616697..106a09505 100644
--- a/sdk-java/src/main/java/ly/count/sdk/java/internal/SessionImpl.java
+++ b/sdk-java/src/main/java/ly/count/sdk/java/internal/SessionImpl.java
@@ -189,11 +189,6 @@ Future<Boolean> end(Long now, final Tasks.Callback<Boolean> callback, String did
 
         this.consents = SDKCore.instance.consents;
 
-        //        // TODO: check if needed
-        //        for (Event event: timedEvents.values()) {
-        //            event.endAndRecord();
-        //        }
-
         if (currentView != null) {
             currentView.stop(true);
         } else {
diff --git a/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleDeviceIdTests.java b/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleDeviceIdTests.java
index bdfd57529..04b81488e 100644
--- a/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleDeviceIdTests.java
+++ b/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleDeviceIdTests.java
@@ -1,5 +1,11 @@
 package ly.count.sdk.java.internal;
 
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import ly.count.sdk.java.Config;
 import ly.count.sdk.java.Countly;
 import org.junit.After;
 import org.junit.Assert;
@@ -14,6 +20,7 @@ public class ModuleDeviceIdTests {
     @After
     public void stop() {
         Countly.instance().halt();
+        SDKCore.testDummyModule = null;
     }
 
     @Before
@@ -28,17 +35,8 @@ public void beforeTest() {
      */
     @Test
     public void generatedDeviceId() {
-        Countly.instance().init(TestUtils.getBaseConfig().setCustomDeviceId(null));
-        String deviceId = null;
-        //todo remove this "while loop" mess after refactoring the SDK
-        while (deviceId == null) { //wait for device ID to be generated
-            try {
-                deviceId = Countly.instance().getDeviceId();
-            } catch (Exception ignored) {
-                //do nothing
-            }
-        }
-        Assert.assertTrue(deviceId.startsWith("CLY_"));
+        Countly.instance().init(TestUtils.getBaseConfig(null));
+        validateDeviceIdIsSdkGenerated();
     }
 
     /**
@@ -48,7 +46,554 @@ public void generatedDeviceId() {
      */
     @Test
     public void customDeviceId() {
-        Countly.instance().init(TestUtils.getBaseConfig());
-        Assert.assertFalse(Countly.instance().getDeviceId().contains("CLY_"));
+        Countly.instance().init(TestUtils.getBaseConfig(TestUtils.DEVICE_ID));
+        validateDeviceIdDeveloperSupplied(TestUtils.DEVICE_ID);
+    }
+
+    /**
+     * "changeWithMerge"
+     * Validating that only one began session request is created and two device id change request for two
+     * "changeWithMerge" calls with different ids
+     * SDK must generate an id first, then should change with developer supplied two times
+     */
+    @Test
+    public void changeWithMerge() {
+        TestUtils.AtomicString deviceID = new TestUtils.AtomicString(TestUtils.DEVICE_ID);
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(deviceID, false, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupView_Event_Session();
+        Assert.assertEquals(1, TestUtils.getCurrentRQ().length); // began session request
+        // validate began session request with generated id
+        validateBeganSessionRequest();
+        validateDeviceIdIsSdkGenerated(); // validate device id generated by the sdk
+
+        String oldDeviceId = Countly.instance().deviceId().getID();
+        Assert.assertEquals(0, callCount.get()); // validate "deviceIdChanged" callback not called
+
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+        Countly.instance().deviceId().changeWithMerge(deviceID.value); // TestUtils.DEVICE_ID
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+
+        Assert.assertEquals(1, callCount.get());
+        validateDeviceIdWithMergeChange(oldDeviceId, 1, 2);
+
+        deviceID.value += "1";
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+        Countly.instance().deviceId().changeWithMerge(deviceID.value); // TestUtils.DEVICE_ID + "1"
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+
+        Assert.assertEquals(2, callCount.get());
+        validateDeviceIdWithMergeChange(TestUtils.DEVICE_ID, 2, 3);
+    }
+
+    /**
+     * "changeWithoutMerge" with custom device id
+     * Validating that new id set and callback is called, and existing events,timed events and session must end, new session must begin
+     * request order should be first began session, 1 events, 1 end session, second began session, second end session, third began session
+     */
+    @Test
+    public void changeWithoutMerge() throws InterruptedException {
+        //why atomic string? Because changing it should also trigger dummy module callback asserts.
+        //so it should be modifiable from outside
+        TestUtils.AtomicString deviceID = new TestUtils.AtomicString(TestUtils.keysValues[0]);
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(deviceID, true, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(TestUtils.DEVICE_ID)); //custom id given
+        setupView_Event_Session(); // setup view, event and session to simulate a device id change
+        validateBeganSessionRequest(); // also validates rq size is 1
+
+        validateDeviceIdDeveloperSupplied(TestUtils.DEVICE_ID);
+        Assert.assertEquals(0, callCount.get());
+
+        Thread.sleep(1000); // waiting for timed event duration
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should be 2 one view and a casual event
+        Countly.instance().deviceId().changeWithoutMerge(deviceID.value);
+        Assert.assertEquals(0, TestUtils.getCurrentEQ().size()); // size should be zero because queue is flushed
+        Assert.assertEquals(1, callCount.get());
+        validateDeviceIdWithoutMergeChange(4, TestUtils.DEVICE_ID); // there should be 2 began, 1 end, 1 events request
+        TestUtils.flushCurrentRQWithOldDeviceId(TestUtils.DEVICE_ID); // clean current rq with old device id requests
+
+        deviceID.value += "1"; //change device id
+        Countly.instance().deviceId().changeWithoutMerge(deviceID.value);
+        Assert.assertEquals(2, callCount.get());
+        //if device id is not merged, then device id change request should not exist
+        validateDeviceIdWithoutMergeChange(3, TestUtils.keysValues[0]); // additional 1 session end 1 session begin, no events because no events exist
+    }
+
+    /**
+     * "changeWithoutMerge" multiple calls with same id
+     * Validating that only one request added, and it is first began session request, also events queue not flushed and callback should not be called
+     * SDK must generate an id first, call must not change anything
+     */
+    @Test
+    public void changeWithoutMerge_sameDeviceId() {
+        //why atomic string? Because changing it should also trigger dummy module callback asserts.
+        //so it should be modifiable from outside
+        TestUtils.AtomicString deviceID = new TestUtils.AtomicString(TestUtils.keysValues[0]);
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(deviceID, true, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); //let sdk generate
+        setupView_Event_Session(); // setup view, event and session to simulate a device id change
+        validateBeganSessionRequest(); // also validates rq size is 1
+        validateDeviceIdIsSdkGenerated();
+
+        Assert.assertEquals(0, callCount.get());
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should be 2 one view and a casual event
+        Countly.instance().deviceId().changeWithoutMerge(Countly.instance().deviceId().getID()); // same device id
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // nothing should change
+        Assert.assertEquals(0, callCount.get());
+        validateBeganSessionRequest(); // also validates rq size is 1 and it is first began session request
+    }
+
+    /**
+     * "changeWithoutMerge" with null device id
+     * Validating that only one request added, and it should be a began session request, callback must not be called, and event queue should not be flushed
+     * SDK must generate an id first, calling with null given id should not trigger anything
+     */
+    @Test
+    public void changeWithoutMerge_nullDeviceId() {
+        //why atomic string? Because changing it should also trigger dummy module callback asserts.
+        //so it should be modifiable from outside
+        TestUtils.AtomicString deviceID = new TestUtils.AtomicString(TestUtils.keysValues[0]);
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(deviceID, true, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); //let sdk generate
+        setupView_Event_Session(); // setup view, event and session to simulate a device id change
+        validateBeganSessionRequest(); // also validates rq size is 1
+        validateDeviceIdIsSdkGenerated();
+
+        Assert.assertEquals(0, callCount.get());
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should be 2 one view and a casual event
+        Countly.instance().deviceId().changeWithoutMerge(null); // null device id
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // nothing should change
+        Assert.assertEquals(0, callCount.get());
+        validateBeganSessionRequest(); // also validates rq size is 1 and it is first began session request
+    }
+
+    /**
+     * "changeWithoutMerge" with empty device id
+     * Validating that only one request added, and it should be a began session request, callback must not be called, and event queue should not be flushed
+     * SDK must generate an id first, calling with null given id should not trigger anything
+     */
+    @Test
+    public void changeWithoutMerge_emptyDeviceId() {
+        //why atomic string? Because changing it should also trigger dummy module callback asserts.
+        //so it should be modifiable from outside
+        TestUtils.AtomicString deviceID = new TestUtils.AtomicString(TestUtils.keysValues[0]);
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(deviceID, true, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); //let sdk generate
+        setupView_Event_Session(); // setup view, event and session to simulate a device id change
+        validateBeganSessionRequest(); // also validates rq size is 1
+        validateDeviceIdIsSdkGenerated();
+
+        Assert.assertEquals(0, callCount.get());
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should be 2 one view and a casual event
+        Countly.instance().deviceId().changeWithoutMerge(""); // null device id
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // nothing should change
+        Assert.assertEquals(0, callCount.get());
+        validateBeganSessionRequest(); // also validates rq size is 1 and it is first began session request
+    }
+
+    /**
+     * "changeWithMerge" with null device id
+     * Validating that only one request added, and it should be a began session request, callback must not be called
+     * SDK must generate an id first, calling with null given id should not trigger anything
+     */
+    @Test
+    public void changeWithMerge_nullDeviceId() {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(null, false, DeviceIdType.SDK_GENERATED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupView_Event_Session();
+
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+        Countly.instance().deviceId().changeWithMerge(null);
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+
+        Assert.assertEquals(0, callCount.get());// validate callback not called
+        validateBeganSessionRequest(); // also validates rq size is 1
+    }
+
+    /**
+     * "changeWithMerge" with empty device id
+     * Validating that only one request added, and it should be a began session request, callback must not be called
+     * SDK must generate an id first, calling with empty given id should not trigger anything
+     */
+    @Test
+    public void changeWithMerge_emptyDeviceId() {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(new TestUtils.AtomicString(""), false, DeviceIdType.SDK_GENERATED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupView_Event_Session();
+
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+        Countly.instance().deviceId().changeWithMerge("");
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+
+        Assert.assertEquals(0, callCount.get()); // validate callback not called
+        validateBeganSessionRequest(); // also validates rq size is 1
+    }
+
+    /**
+     * "changeWithMerge" multiple calls with same id
+     * Validating that only two request added, one is session began, and other should be device id change request
+     * and callback should be called only once
+     * SDK must generate an id first, then should change with developer supplied. Second call must not change anything
+     */
+    @Test
+    public void changeWithMerge_sameDeviceId() {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(new TestUtils.AtomicString(TestUtils.DEVICE_ID), false, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupView_Event_Session();
+        validateBeganSessionRequest(); // also validates rq size is 1
+
+        String oldDeviceId = Countly.instance().deviceId().getID();
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // one view and one casual event
+        Countly.instance().deviceId().changeWithMerge(TestUtils.DEVICE_ID);
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+        Assert.assertEquals(1, callCount.get());
+        validateDeviceIdWithMergeChange(oldDeviceId, 1, 2);
+
+        Countly.instance().deviceId().changeWithMerge(TestUtils.DEVICE_ID);
+        Assert.assertEquals(1, callCount.get());
+        Assert.assertEquals(2, TestUtils.getCurrentEQ().size()); // size should not change because it is merge request
+
+        validateDeviceIdWithMergeChange(oldDeviceId, 1, 2);
+    }
+
+    /**
+     * "changeWithMerge" with not started session
+     * Validating that only one request must exist and it should be a device id change request and callback should be called only once
+     * SDK must generate an id first, then should change with developer supplied. Only one request must exist
+     */
+    @Test
+    public void changeWithMerge_sessionNotStarted() {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(new TestUtils.AtomicString(TestUtils.DEVICE_ID), false, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupEvent();
+
+        String oldDeviceId = Countly.instance().deviceId().getID();
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+
+        Assert.assertEquals(1, TestUtils.getCurrentEQ().size()); //  one casual event no timed event because not end
+        Countly.instance().deviceId().changeWithMerge(TestUtils.DEVICE_ID);
+        Assert.assertEquals(1, TestUtils.getCurrentEQ().size()); //  one casual event no timed event because not end
+
+        Assert.assertEquals(1, callCount.get());
+        validateDeviceIdWithMergeChange(oldDeviceId, 0, 1);
+    }
+
+    /**
+     * "changeWithoutMerge" with not started session
+     * Validating that only one request must exist and it should be the second begin session request and callback should be called only once
+     * SDK must generate an id first, then should change with developer supplied. Only one request must exist
+     */
+    @Test
+    public void changeWithoutMerge_sessionNotStarted() {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(new TestUtils.AtomicString(TestUtils.DEVICE_ID), true, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+
+        Countly.instance().deviceId().changeWithoutMerge(TestUtils.DEVICE_ID);
+        Assert.assertEquals(1, callCount.get());
+        validateBeganSessionRequest(); // only began session request must exist for new device id, no event created
+    }
+
+    /**
+     * "changeWithoutMerge" with not started session, and with created events
+     * Validating that only two request must exist one is events and the other should be the second begin session request and callback should be called only once
+     * SDK must generate an id first, then should change with developer supplied. Only two request must exist
+     */
+    @Test
+    public void changeWithoutMerge_sessionNotStarted_withEvents() throws InterruptedException {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(new TestUtils.AtomicString(TestUtils.DEVICE_ID), true, DeviceIdType.DEVELOPER_SUPPLIED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupEvent(); // two events created one is timed event it is started, the other is casual event
+        String oldDeviceId = Countly.instance().deviceId().getID();
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+
+        Assert.assertEquals(1, TestUtils.getCurrentEQ().size()); // should be one because timed event is not end
+        Thread.sleep(1000); // wait for timed event
+        Countly.instance().deviceId().changeWithoutMerge(TestUtils.DEVICE_ID);
+        Assert.assertEquals(1, callCount.get());
+        Assert.assertEquals(0, TestUtils.getCurrentEQ().size()); // should flush because without merge request
+
+        validateEvents(0, oldDeviceId, 1); // validate events exist with old device id
+        validateBeganSessionRequest(1); // this also validates request queue size it is index + 1
+    }
+
+    /**
+     * "getID", "getType"
+     * Custom id is not given, validating that device id is sdk generated
+     * Type must be 'SDK_GENERATED' and generated id should be a valid UUID
+     */
+    @Test
+    public void getID_getType() {
+        Countly.instance().init(TestUtils.getBaseConfig(null)); // no custom id given
+        validateDeviceIdIsSdkGenerated(); // validate id is a valid UUID
+    }
+
+    /**
+     * "getID", "getType"
+     * Custom id is given, validating that device id is developer supplied
+     * Type must be 'DEVELOPER_SUPPLIED' and generated id should be same with the given id
+     */
+    @Test
+    public void getID_getType_customDeviceId() {
+        Countly.instance().init(TestUtils.getBaseConfig(TestUtils.DEVICE_ID)); // custom id given
+        validateDeviceIdDeveloperSupplied(TestUtils.DEVICE_ID);
+    }
+
+    /**
+     * "logout"
+     * Validating that all required requests are added, order should be first began session, 1 events, 1 end session, second began session
+     * uuid strategy generates a new id
+     */
+    @Test
+    public void logout_sdkGenerated() throws InterruptedException {
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(null, true, DeviceIdType.SDK_GENERATED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(null)); // to create sdk generated device id
+        setupView_Event_Session();
+
+        validateDeviceIdIsSdkGenerated();
+        Assert.assertEquals(0, callCount.get());
+        String oldDeviceId = Countly.instance().deviceId().getID();
+
+        Thread.sleep(1000);  // waiting for timed event duration
+        Countly.instance().logout();
+        Assert.assertEquals(1, callCount.get());
+        validateDeviceIdWithoutMergeChange(4, oldDeviceId);
+    }
+
+    /**
+     * "logout" with custom device id
+     * Validating that no request added other than first began session request
+     * custom strategy does not generate a new id because it is always same
+     */
+    @Test
+    public void logout_developerSupplied() {
+        TestUtils.AtomicString deviceID = new TestUtils.AtomicString(TestUtils.DEVICE_ID);
+        AtomicInteger callCount = initDummyModuleForDeviceIdChangedCallback(deviceID, true, DeviceIdType.SDK_GENERATED);
+        Countly.instance().init(TestUtils.getConfigDeviceId(TestUtils.DEVICE_ID)); // to create sdk generated device id
+        setupView_Event_Session();
+
+        validateDeviceIdDeveloperSupplied(TestUtils.DEVICE_ID);
+        Assert.assertEquals(0, callCount.get());
+
+        Countly.instance().logout();
+        Assert.assertEquals(0, callCount.get()); // custom strategy only generates same id
+        validateBeganSessionRequest();// only began request exist
+    }
+
+    /**
+     * "acquireId"
+     * Validating that acquired id is sdk generated and UUID
+     * Acquired id must comply to UUID structure
+     */
+    @Test
+    public void acquireId_sdkGenerated() {
+        Countly.instance().init(TestUtils.getBaseConfig(null)); // no custom id provided
+        validateDeviceIdIsSdkGenerated(); // validate id exist and sdk generated
+
+        Config.DID did = SDKCore.instance.module(ModuleDeviceIdCore.class).acquireId();
+        validateDeviceIdIsUUID(did.id);
+    }
+
+    /**
+     * "acquireId"
+     * Validating that acquired id is developer supplied
+     * Acquired id must be same with the given id
+     */
+    @Test
+    public void acquireId_customId() {
+        Countly.instance().init(TestUtils.getBaseConfig(TestUtils.DEVICE_ID)); // custom id provided
+        validateDeviceIdDeveloperSupplied(TestUtils.DEVICE_ID); // validate id exist and developer supplied
+
+        Config.DID did = SDKCore.instance.module(ModuleDeviceIdCore.class).acquireId();
+        Assert.assertEquals(TestUtils.DEVICE_ID, did.id);
+    }
+
+    /**
+     * validates that requests in RQ are valid for without merge request
+     * It validates the requests after a without merge device id change
+     * There are 4 requests possibility:
+     * - First begin session request (required) #has old device id
+     * - An event queue request which contains views, timed events and events (not required) #has old device id
+     * - An end session request (required) #has old device id
+     * - Second begin session request (required) #has new device id
+     * <p>
+     * So at least 3 requests must exist in the RQ
+     *
+     * This validator assumes that a session was started at the start and automatic sessions are enabled (which will start the session afterwards)
+     *
+     * @param rqSize expected RQ size
+     * @param oldDeviceId to validate device id in requests before device id change
+     */
+    private void validateDeviceIdWithoutMergeChange(final int rqSize, String oldDeviceId) {
+        Map<String, String>[] requests = TestUtils.getCurrentRQ();
+        Assert.assertEquals(rqSize, TestUtils.getCurrentRQ().length);
+
+        // validate first begin session request
+        TestUtils.validateRequiredParams(requests[0], oldDeviceId); // first request must be began session request
+        TestUtils.validateMetrics(requests[0].get("metrics")); // validate metrics exist in the first session request
+        Assert.assertEquals("1", requests[0].get("begin_session")); // validate begin session value is 1
+
+        int remainingRequestIndex = 1; // if there is no event request, then this will be 1 to continue checking
+
+        // validate event request if exists
+        try {
+            List<EventImpl> existingEvents = validateEvents(1, oldDeviceId, 2);
+            if (!existingEvents.isEmpty()) {
+                Map<String, Object> viewSegmentation = new ConcurrentHashMap<>();
+                viewSegmentation.put("segment", Device.dev.getOS());
+                viewSegmentation.put("name", TestUtils.keysValues[1]);
+                viewSegmentation.put("start", "1");
+                viewSegmentation.put("visit", "1");
+                TestUtils.validateEvent(existingEvents.get(1), "[CLY]_view", viewSegmentation, 1, null, null); // view start event
+                viewSegmentation.remove("start");
+                viewSegmentation.remove("visit");
+                TestUtils.validateEvent(existingEvents.get(3), "[CLY]_view", viewSegmentation, 1, null, 1.0); // view stop event
+                remainingRequestIndex++;
+            }
+        } catch (NullPointerException ignored) {
+            //do nothing
+        }
+
+        // validate end session request
+        TestUtils.validateRequiredParams(requests[remainingRequestIndex], oldDeviceId); // second begin session request must have new device id
+        Assert.assertEquals("1", requests[remainingRequestIndex].get("end_session")); // validate begin session value is 1
+        remainingRequestIndex++;
+        // validate second begin session request
+        TestUtils.validateRequiredParams(requests[remainingRequestIndex], Countly.instance().deviceId().getID()); // second begin session request must have new device id
+        TestUtils.validateMetrics(requests[remainingRequestIndex].get("metrics")); // validate metrics exist in the second session request
+        Assert.assertEquals("1", requests[remainingRequestIndex].get("begin_session")); // validate begin session value is 1
+    }
+
+    /**
+     * Validates that the device id change request is valid
+     *
+     * @param oldDeviceId expected value of "old_device_id" param
+     * @param rqIdx index of the request in the RQ
+     * @param rqSize expected RQ size
+     */
+    private void validateDeviceIdWithMergeChange(String oldDeviceId, final int rqIdx, final int rqSize) {
+        Map<String, String>[] requests = TestUtils.getCurrentRQ();
+        Assert.assertEquals(rqSize, TestUtils.getCurrentRQ().length);
+
+        TestUtils.validateRequiredParams(requests[rqIdx], Countly.instance().deviceId().getID());
+        Assert.assertEquals(oldDeviceId, requests[rqIdx].get("old_device_id"));
+    }
+
+    /**
+     * Initializes the dummy module to listen for device id change callbacks
+     *
+     * @param deviceId to validate expected device id is set
+     * @param withoutMerge to validate its value
+     * @param type to validate by types
+     * @return call count of the callback
+     */
+    private AtomicInteger initDummyModuleForDeviceIdChangedCallback(TestUtils.AtomicString deviceId, boolean withoutMerge, DeviceIdType type) {
+        AtomicInteger callCount = new AtomicInteger(0);
+        SDKCore.testDummyModule = new ModuleBase() {
+            @Override
+            protected void deviceIdChanged(String oldDeviceId, boolean withMerge) {
+                super.deviceIdChanged(oldDeviceId, withMerge);
+                callCount.incrementAndGet();
+                Assert.assertEquals(!withoutMerge, withMerge);
+                if (type == DeviceIdType.SDK_GENERATED) {
+                    validateDeviceIdIsSdkGenerated();
+                } else {
+                    validateDeviceIdDeveloperSupplied(deviceId.value);
+                }
+                Assert.assertEquals(type.index, internalConfig.getDeviceId().strategy);
+            }
+        };
+
+        return callCount;
+    }
+
+    private void validateDeviceIdDeveloperSupplied(String expectedDeviceId) {
+        Assert.assertEquals(expectedDeviceId, Countly.instance().deviceId().getID());
+        Assert.assertEquals(DeviceIdType.DEVELOPER_SUPPLIED, Countly.instance().deviceId().getType());
+    }
+
+    private void validateDeviceIdIsSdkGenerated() {
+        String deviceId = Countly.instance().deviceId().getID();
+        try {
+            validateDeviceIdIsUUID(deviceId);
+            Assert.assertEquals(DeviceIdType.SDK_GENERATED, Countly.instance().deviceId().getType());
+        } catch (IllegalArgumentException e) {
+            Assert.fail("Device id is not a valid UUID");
+        }
+    }
+
+    /**
+     * Validates that the device id is a valid UUID and starts with "CLY_"
+     */
+    private void validateDeviceIdIsUUID(String deviceId) {
+        try {
+            Assert.assertTrue(deviceId.startsWith("CLY_"));
+            String[] parts = deviceId.split("CLY_");
+            UUID uuid = UUID.fromString(parts[1]);
+            Assert.assertEquals(parts[1], uuid.toString());
+        } catch (IllegalArgumentException e) {
+            Assert.fail("Device id is not a valid UUID");
+        }
+    }
+
+    /**
+     * Validates that the began session request is valid
+     * and it should be the first request
+     */
+    private void validateBeganSessionRequest() {
+        validateBeganSessionRequest(0); // always 0 because it is at the first request
+    }
+
+    /**
+     * Validates that the began session request is valid
+     * and it should be at the index request
+     */
+    private void validateBeganSessionRequest(int index) {
+        Map<String, String>[] requests = TestUtils.getCurrentRQ();
+        Assert.assertEquals(index + 1, requests.length); // always 1 because it is the first request
+        TestUtils.validateRequiredParams(requests[index], Countly.instance().deviceId().getID());
+    }
+
+    /**
+     * Creates a view, a session and an event to simulate what
+     * happens when a device id change occurs
+     */
+    private void setupView_Event_Session() {
+        Countly.session().begin();
+        setupEvent();
+        Countly.instance().view(TestUtils.keysValues[1]).start(true);
+    }
+
+    private void setupEvent() {
+        Countly.instance().events().startEvent(TestUtils.keysValues[0]);
+        Countly.instance().events().recordEvent(TestUtils.keysValues[2]);
+    }
+
+    /**
+     * This function validates pre-defined things
+     * There should be two events, one is timed event it is started, the other is casual event
+     * All keys are validated like in the function body
+     */
+    private List<EventImpl> validateEvents(int requestIndex, String deviceId, int timedEventIdx) {
+        List<EventImpl> existingEvents = TestUtils.readEventsFromRequest(requestIndex, deviceId);
+        if (!existingEvents.isEmpty()) {
+            TestUtils.validateEvent(existingEvents.get(0), TestUtils.keysValues[2], null, 1, null, null); // casual event
+            TestUtils.validateEvent(existingEvents.get(timedEventIdx), TestUtils.keysValues[0], null, 1, null, 1.0); // timed event
+        }
+
+        return existingEvents;
     }
 }
diff --git a/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleRemoteConfigTests.java b/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleRemoteConfigTests.java
index cf14be233..346a8038e 100644
--- a/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleRemoteConfigTests.java
+++ b/sdk-java/src/test/java/ly/count/sdk/java/internal/ModuleRemoteConfigTests.java
@@ -179,9 +179,7 @@ public void removeDownloadCallback_null() {
      */
     @Test
     public void removeDownloadCallback() {
-        RCDownloadCallback callback = (rResult, error, fullValueUpdate, downloadedValues) -> {
-            Assert.assertEquals(RequestResult.Success, rResult);
-        };
+        RCDownloadCallback callback = (rResult, error, fullValueUpdate, downloadedValues) -> Assert.assertEquals(RequestResult.Success, rResult);
         Countly.instance().init(TestUtils.getConfigRemoteConfigs().remoteConfigRegisterGlobalCallback(callback));
         ModuleRemoteConfig rcModule = SDKCore.instance.module(ModuleRemoteConfig.class);
 
@@ -438,7 +436,7 @@ protected static ImmediateRequestI remoteConfigRequestMaker(JSONObject remoteCon
 
             TestUtils.validateMetrics(Utils.urldecode(params.get("metrics")));
             TestUtils.validateRequestMakerRequiredParams("/o/sdk?", customEndpoint, requestShouldBeDelayed, networkingIsEnabled);
-            TestUtils.validateRequiredParams(params);
+            TestUtils.validateRequiredParams(params, Countly.instance().deviceId().getID());
             callback.callback(remoteConfigMockData);
         };
     }
diff --git a/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioDeviceIdInitTests.java b/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioDeviceIdInitTests.java
index 6ee766a07..b413555a7 100644
--- a/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioDeviceIdInitTests.java
+++ b/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioDeviceIdInitTests.java
@@ -1,6 +1,5 @@
 package ly.count.sdk.java.internal;
 
-import ly.count.sdk.java.Config;
 import ly.count.sdk.java.Countly;
 import org.junit.After;
 import org.junit.Assert;
@@ -39,7 +38,7 @@ public void firstInit_ProvidedNothing() {
         Countly.instance().init(TestUtils.getBaseConfig(null));
 
         assertIsSDKGeneratedID(Countly.instance().deviceId().getID());
-        Assert.assertEquals(Config.DeviceIdStrategy.UUID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.SDK_GENERATED, Countly.instance().deviceId().getType());
     }
 
     /**
@@ -52,7 +51,7 @@ public void firstInit_ProvidedCustomId() {
         Countly.instance().init(TestUtils.getBaseConfig(TestUtils.DEVICE_ID));
 
         Assert.assertEquals(TestUtils.DEVICE_ID, Countly.instance().deviceId().getID());
-        Assert.assertEquals(Config.DeviceIdStrategy.CUSTOM_ID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.DEVELOPER_SUPPLIED, Countly.instance().deviceId().getType());
     }
 
     //followup init where:
@@ -68,14 +67,14 @@ public void followupInit_FirstNothingProvidedNothing() {
 
         String initialDId = Countly.instance().deviceId().getID();
         assertIsSDKGeneratedID(initialDId);
-        Assert.assertEquals(Config.DeviceIdStrategy.UUID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.SDK_GENERATED, Countly.instance().deviceId().getType());
 
         //setup followup state
         Countly.instance().stop();
         Countly.instance().init(TestUtils.getBaseConfig(null));
 
         Assert.assertEquals(initialDId, Countly.instance().deviceId().getID());
-        Assert.assertEquals(Config.DeviceIdStrategy.UUID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.SDK_GENERATED, Countly.instance().deviceId().getType());
     }
 
     /**
@@ -90,15 +89,14 @@ public void followupInit_FirstNothingProvidedCustomId() {
         String initialDId = Countly.instance().deviceId().getID();
 
         assertIsSDKGeneratedID(initialDId);
-        Assert.assertEquals(Config.DeviceIdStrategy.UUID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.SDK_GENERATED, Countly.instance().deviceId().getType());
 
         //setup followup state
         Countly.instance().stop();
         Countly.instance().init(TestUtils.getBaseConfig(alternativeDeviceID));
 
         Assert.assertEquals(initialDId, Countly.instance().deviceId().getID());
-        //todo this is what the SDK should return
-        //Assert.assertEquals(Config.DeviceIdStrategy.UUID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.SDK_GENERATED, Countly.instance().deviceId().getType());
     }
 
     /**
@@ -112,14 +110,14 @@ public void followupInit_FirstCustomProvidedCustomId() {
         Countly.instance().init(TestUtils.getBaseConfig(TestUtils.DEVICE_ID));
 
         Assert.assertEquals(TestUtils.DEVICE_ID, Countly.instance().deviceId().getID());
-        Assert.assertEquals(Config.DeviceIdStrategy.CUSTOM_ID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.DEVELOPER_SUPPLIED, Countly.instance().deviceId().getType());
 
         //setup followup state
         Countly.instance().stop();
         Countly.instance().init(TestUtils.getBaseConfig(alternativeDeviceID));
 
         Assert.assertEquals(TestUtils.DEVICE_ID, Countly.instance().deviceId().getID());
-        Assert.assertEquals(Config.DeviceIdStrategy.CUSTOM_ID.getIndex(), SDKCore.instance.config.getDeviceIdStrategy());
+        Assert.assertEquals(DeviceIdType.DEVELOPER_SUPPLIED, Countly.instance().deviceId().getType());
     }
 
     void assertIsSDKGeneratedID(String providedID) {
diff --git a/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioRemoteConfigDeviceIdChangeTests.java b/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioRemoteConfigDeviceIdChangeTests.java
index acbaf4108..10f8de836 100644
--- a/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioRemoteConfigDeviceIdChangeTests.java
+++ b/sdk-java/src/test/java/ly/count/sdk/java/internal/ScenarioRemoteConfigDeviceIdChangeTests.java
@@ -49,7 +49,7 @@ public void changeDeviceIdWithMerge() {
         Assert.assertEquals(1, Countly.instance().remoteConfig().getValues().size());
 
         //change device id
-        Countly.instance().changeDeviceIdWithMerge(TestUtils.keysValues[0]);
+        Countly.instance().deviceId().changeWithMerge(TestUtils.keysValues[0]);
 
         Countly.instance().remoteConfig().getValues().forEach((key, value) -> Assert.assertTrue(value.isCurrentUsersData));
         Assert.assertEquals(3, Countly.instance().remoteConfig().getValues().size());
@@ -76,7 +76,7 @@ public void changeDeviceIdWithoutMerge() {
         Assert.assertEquals(1, Countly.instance().remoteConfig().getValues().size());
 
         //change device id
-        Countly.instance().changeDeviceIdWithoutMerge(TestUtils.keysValues[0]);
+        Countly.instance().deviceId().changeWithoutMerge(TestUtils.keysValues[0]);
 
         Countly.instance().remoteConfig().getValues().forEach((key, value) -> Assert.assertTrue(value.isCurrentUsersData));
         Assert.assertEquals(3, Countly.instance().remoteConfig().getValues().size());
diff --git a/sdk-java/src/test/java/ly/count/sdk/java/internal/TestUtils.java b/sdk-java/src/test/java/ly/count/sdk/java/internal/TestUtils.java
index 45034d299..5e5fdce42 100644
--- a/sdk-java/src/test/java/ly/count/sdk/java/internal/TestUtils.java
+++ b/sdk-java/src/test/java/ly/count/sdk/java/internal/TestUtils.java
@@ -76,6 +76,10 @@ static Config getConfigSessions(Config.Feature... features) {
         return config;
     }
 
+    static Config getConfigDeviceId(String deviceId) {
+        return getBaseConfig(deviceId).enableFeatures(Config.Feature.Sessions, Config.Feature.Views, Config.Feature.Events).setEventQueueSizeToSend(10);
+    }
+
     static Config getConfigSessions() {
         return getConfigSessions((Config.Feature) null);
     }
@@ -158,6 +162,21 @@ protected static Map<String, String>[] getCurrentRQ(File targetFolder, Log logge
         return resultMapArray;
     }
 
+    static void flushCurrentRQWithOldDeviceId(String oldDeviceId) {
+        Arrays.stream(getRequestFiles(getTestSDirectory())).forEach(file -> {
+            try {
+                if (file.exists() && file.isFile()) {
+                    String content = Utils.readFileContent(file, mock(Log.class));
+                    if (content.contains(oldDeviceId)) {
+                        Files.delete(file.toPath());
+                    }
+                }
+            } catch (IOException ignored) {
+                //do nothing
+            }
+        });
+    }
+
     protected static List<EventImpl> getCurrentEQ() {
         return getCurrentEQ(getTestSDirectory(), mock(Log.class));
     }
@@ -223,7 +242,7 @@ private static File[] getRequestFiles(File targetFolder) {
         //stream all files from target folder and filter only request files and sort them by last modified
         return Stream.of(files)
             .filter(file -> file.getName().startsWith("[CLY]_request_"))
-            .sorted(Comparator.comparing(file -> Long.parseLong(file.getName().split("_")[3])))
+            .sorted(Comparator.comparing(file -> Long.parseLong(file.getName().split("_")[2])))
             .toArray(File[]::new);
     }
 
@@ -299,12 +318,12 @@ static void validateEventInEQ(String key, Map<String, Object> segmentation, int
     }
 
     static List<EventImpl> readEventsFromRequest() {
-        return readEventsFromRequest(0);
+        return readEventsFromRequest(0, TestUtils.DEVICE_ID);
     }
 
-    static List<EventImpl> readEventsFromRequest(int requestIndex) {
+    static List<EventImpl> readEventsFromRequest(int requestIndex, String deviceId) {
         Map<String, String> request = getCurrentRQ()[requestIndex];
-        validateRequiredParams(request);
+        validateRequiredParams(request, deviceId);
         JSONArray array = new JSONArray(request.get("events"));
         List<EventImpl> result = new ArrayList<>();
 
@@ -349,12 +368,16 @@ static void writeToFile(final String fileName, final String data) {
     }
 
     public static void validateRequiredParams(Map<String, String> params) {
+        validateRequiredParams(params, TestUtils.DEVICE_ID);
+    }
+
+    public static void validateRequiredParams(Map<String, String> params, String deviceId) {
         int hour = Integer.parseInt(params.get("hour"));
         int dow = Integer.parseInt(params.get("dow"));
         int tz = Integer.parseInt(params.get("tz"));
 
         validateSdkIdentityParams(params);
-        Assert.assertEquals(SDKCore.instance.config.getDeviceId().id, params.get("device_id"));
+        Assert.assertEquals(deviceId, params.get("device_id"));
         Assert.assertEquals(SERVER_APP_KEY, params.get("app_key"));
         Assert.assertEquals(APPLICATION_VERSION, params.get("av"));
         Assert.assertTrue(Long.parseLong(params.get("timestamp")) > 0);
@@ -465,4 +488,12 @@ static void validateMetrics(String metrics) {
         Params params = Device.dev.buildMetrics();
         Assert.assertEquals(params.get("metrics"), metrics);
     }
+
+    static class AtomicString {
+        String value;
+
+        public AtomicString(String value) {
+            this.value = value;
+        }
+    }
 }
\ No newline at end of file