diff --git a/examples/java-matter-controller/java/src/com/matter/controller/Main.java b/examples/java-matter-controller/java/src/com/matter/controller/Main.java
index 11b067a6f782bd..0f00c50a18700a 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/Main.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/Main.java
@@ -84,13 +84,6 @@ private static void registerCommandsPairing(
   }
 
   public static void main(String[] args) {
-    ChipDeviceController controller =
-        new ChipDeviceController(
-            ControllerParams.newBuilder()
-                .setUdpListenPort(0)
-                .setControllerVendorId(0xFFF1)
-                .build());
-
     CredentialsIssuer credentialsIssuer = new CredentialsIssuer();
     CommandManager commandManager = new CommandManager();
 
@@ -104,5 +97,6 @@ public static void main(String[] args) {
     } catch (Exception e) {
       System.out.println("Run command failed with exception: " + e.getMessage());
     }
+
   }
 }
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Argument.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Argument.java
index 8cc53d22f3bbd9..559c244834c231 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Argument.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Argument.java
@@ -112,11 +112,21 @@ public void setValue(String value) {
         String str = (String) mValue;
         isValidArgument = value.equals(str);
         break;
+      case NUMBER_INT16:
+        AtomicInteger numShort = (AtomicInteger) mValue;
+        numShort.set(Integer.parseInt(value));
+        isValidArgument = (numShort.intValue() >= mMin && numShort.intValue() <= mMax);
+        break;
       case NUMBER_INT32:
         AtomicInteger num = (AtomicInteger) mValue;
         num.set(Integer.parseInt(value));
         isValidArgument = (num.intValue() >= mMin && num.intValue() <= mMax);
         break;
+      case NUMBER_INT64:
+        AtomicLong numLong = (AtomicLong) mValue;
+        numLong.set(Long.parseLong(value));
+        isValidArgument = (numLong.intValue() >= mMin && numLong.intValue() <= mMax);
+        break;
       case ADDRESS:
         try {
           IPAddress ipAddress = (IPAddress) mValue;
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Command.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Command.java
index 13ed473f43285f..ee5bf3dad71457 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Command.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/Command.java
@@ -190,5 +190,9 @@ public void initArgument(int argIndex, String argValue) {
     mArgs.get(argIndex).setValue(argValue);
   }
 
+  public Object getArgument(int argIndex) {
+    return mArgs.get(argIndex);
+  }
+
   public abstract void run() throws Exception;
 }
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/CommandManager.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/CommandManager.java
index edcc61c3be86cc..accd8d8b1da94e 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/CommandManager.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/CommandManager.java
@@ -89,10 +89,10 @@ public final void run(String[] args) {
       }
     }
 
-    String[] temp = Arrays.copyOfRange(args, 1, args.length);
+    String[] temp = Arrays.copyOfRange(args, 2, args.length);
 
     try {
-      command.initArguments(args.length - 1, temp);
+      command.initArguments(args.length - 2, temp);
       command.run();
     } catch (IllegalArgumentException e) {
       System.out.println("Arguments init failed with exception: " + e.getMessage());
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/IPAddress.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/IPAddress.java
index 814a9c7efbd429..c4e0a528dc8aa9 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/IPAddress.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/IPAddress.java
@@ -15,6 +15,6 @@ public void setAddress(InetAddress address) {
 
   @Override
   public String toString() {
-    return address.toString();
+    return address.getHostAddress();
   }
 }
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/MatterCommand.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/MatterCommand.java
index 8b0b068ba5c2a9..d1f75548091f53 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/common/MatterCommand.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/common/MatterCommand.java
@@ -39,6 +39,7 @@ public abstract class MatterCommand extends Command {
   private final AtomicLong mCommissionerNodeId = new AtomicLong();
   private final AtomicBoolean mUseMaxSizedCerts = new AtomicBoolean();;
   private final AtomicBoolean mOnlyAllowTrustedCdKeys = new AtomicBoolean();;
+  private String TestResult = null;
 
   public MatterCommand(String commandName, CredentialsIssuer credIssuerCmds) {
     this(commandName, credIssuerCmds, null);
@@ -47,7 +48,8 @@ public MatterCommand(String commandName, CredentialsIssuer credIssuerCmds) {
   public MatterCommand(String commandName, CredentialsIssuer credIssuerCmds, String helpText) {
     super(commandName, helpText);
     this.mCredIssuerCmds = Optional.ofNullable(credIssuerCmds);
-
+    //TODO: Add support to enable the below optional arguments
+    /*
     addArgument(
         "paa-trust-store-path",
         mPaaTrustStorePath,
@@ -79,12 +81,14 @@ public MatterCommand(String commandName, CredentialsIssuer credIssuerCmds, Strin
         mOnlyAllowTrustedCdKeys,
         "Only allow trusted CD verifying keys (disallow test keys). If not provided or 0 (\"false\"), untrusted CD "
             + "verifying keys are allowed. If 1 (\"true\"), test keys are disallowed.");
+    */
   }
 
   /////////// Command Interface /////////
   @Override
   public void run() throws Exception {
-    maybeSetUpStack();
+    // TODO: setup chip storage from Java, currently it is using example one from chip-tool
+    // maybeSetUpStack();
     runCommand();
     maybeTearDownStack();
   }
@@ -100,4 +104,42 @@ private void maybeSetUpStack() throws Exception {
   private void maybeTearDownStack() {
     // ToDo:We need to call DeviceController::Shutdown()
   }
+
+
+  public void SetTestResult(String result)
+  {
+    TestResult = result;
+  }
+
+  public void ExpectSuccess(long timeout)
+  {
+    ExpectResult("Success", timeout);
+  }
+
+  private void ExpectResult(String expectedResult, long timeout)
+  {
+      long start = System.currentTimeMillis();
+      while (TestResult == null)
+          try 
+          { 
+            if (System.currentTimeMillis() > (start + timeout))
+            {
+              throw new RuntimeException("timeout!");
+            }
+            Thread.sleep(100); 
+          }
+          catch (Exception ex) { }
+
+      if (!TestResult.equals(expectedResult)) {
+          if (!expectedResult.equals("Success"))
+          {
+              System.out.format("%s command failed:%n    Expected: %s%n    Got: %s%n", getName(), expectedResult, TestResult);
+              throw new RuntimeException(getName());
+          }
+          else
+          {
+              System.out.format("%s command failed: %s%n", getName(), TestResult);
+          }
+      }
+  }
 }
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairOnNetworkLongCommand.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairOnNetworkLongCommand.java
index 62ee8c03ccf8c9..1e8533d0a0b15b 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairOnNetworkLongCommand.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairOnNetworkLongCommand.java
@@ -1,6 +1,10 @@
 package com.matter.controller.commands.pairing;
 
 import com.matter.controller.commands.common.CredentialsIssuer;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import chip.devicecontroller.ChipDeviceController;
+import chip.devicecontroller.ControllerParams;
 
 public final class PairOnNetworkLongCommand extends PairingCommand {
   public PairOnNetworkLongCommand(CredentialsIssuer credsIssue) {
@@ -13,5 +17,25 @@ public PairOnNetworkLongCommand(CredentialsIssuer credsIssue) {
   }
 
   @Override
-  protected void runCommand() {}
+  protected void runCommand() {
+    ChipDeviceController controller =
+    new ChipDeviceController(
+        ControllerParams.newBuilder()
+            .setUdpListenPort(0)
+            .setControllerVendorId(0xFFF1)
+            .build());
+
+    controller.pairDeviceWithAddress(
+      getNodeId(),
+      GetRemoteAddr().toString(),
+      5540,
+      getDiscriminator(),
+      getSetupPINCode(),
+      null
+    );
+
+    controller.setCompletionListener(this);
+    ExpectSuccess(getTimeoutMillis());
+    controller.shutdownCommissioning();
+  }
 }
diff --git a/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairingCommand.java b/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairingCommand.java
index 151c88bf8bd2ca..00b30a3bb36cb0 100644
--- a/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairingCommand.java
+++ b/examples/java-matter-controller/java/src/com/matter/controller/commands/pairing/PairingCommand.java
@@ -26,15 +26,16 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
+import chip.devicecontroller.ChipDeviceController;
 
-public abstract class PairingCommand extends MatterCommand {
+public abstract class PairingCommand extends MatterCommand implements ChipDeviceController.CompletionListener{
   private PairingModeType mPairingMode = PairingModeType.NONE;
   private PairingNetworkType mNetworkType = PairingNetworkType.NONE;
   private DiscoveryFilterType mFilterType = DiscoveryFilterType.NONE;
   private final IPAddress mRemoteAddr;
   private final AtomicLong mNodeId = new AtomicLong();
   private final AtomicLong mDiscoveryFilterCode = new AtomicLong();
-  private final AtomicInteger mTimeout = new AtomicInteger();
+  private final AtomicLong mTimeoutMillis = new AtomicLong();
   private final AtomicBoolean mDiscoverOnce = new AtomicBoolean();
   private final AtomicBoolean mUseOnlyOnNetworkDiscovery = new AtomicBoolean();
   private final AtomicInteger mRemotePort = new AtomicInteger();
@@ -45,6 +46,115 @@ public abstract class PairingCommand extends MatterCommand {
   private final StringBuffer mPassword = new StringBuffer();
   private final StringBuffer mOnboardingPayload = new StringBuffer();
   private final StringBuffer mDiscoveryFilterInstanceName = new StringBuffer();
+  
+  public long getNodeId()
+  {
+    return mNodeId.get();
+  }
+
+  public int getSetupPINCode()
+  {
+    return mSetupPINCode.get();
+  }
+
+  public int getDiscriminator()
+  {
+    return mDiscriminator.get();
+  }
+
+  public long getTimeoutMillis()
+  {
+    return mTimeoutMillis.get();
+  }
+
+  @Override
+  public void onConnectDeviceComplete()
+  {
+    System.out.println("onConnectDeviceComplete");
+  }
+
+  @Override
+  public void onStatusUpdate(int status)
+  {
+    System.out.println("onStatusUpdate with status: " + status);
+  }
+
+  @Override
+  public void onPairingComplete(int errorCode)
+  {
+    System.out.println("onPairingComplete with error code: " + errorCode);
+    if (errorCode != 0) {
+      SetTestResult("Failure");
+      throw new RuntimeException("onPairingComplete");
+    }
+  }
+
+  @Override
+  public void onPairingDeleted(int errorCode)
+  {
+    System.out.println("onPairingDeleted with error code: " + errorCode);
+  }
+
+  @Override
+  public void onCommissioningComplete(long nodeId, int errorCode)
+  {
+    System.out.println("onCommissioningComplete with error code: " + errorCode);
+    if (errorCode == 0) {
+      SetTestResult("Success");
+    }
+    else
+    {
+      SetTestResult("Failure");
+      throw new RuntimeException("onCommissioningComplete");
+    }
+  }
+
+  @Override
+  public void onReadCommissioningInfo(
+      int vendorId, int productId, int wifiEndpointId, int threadEndpointId)
+  {
+    System.out.println("onReadCommissioningInfo");
+  }
+
+  @Override
+  public void onCommissioningStatusUpdate(long nodeId, String stage, int errorCode)
+  {
+    System.out.println("onCommissioningStatusUpdate");
+  }
+
+  @Override
+  public void onNotifyChipConnectionClosed()
+  {
+    System.out.println("onNotifyChipConnectionClosed");
+  }
+
+  @Override
+  public void onCloseBleComplete()
+  {
+    System.out.println("onCloseBleComplete");
+  }
+
+  @Override
+  public void onError(Throwable error)
+  {
+    SetTestResult(error.toString());
+    System.out.println("onError with error: " + error.toString());
+    throw new RuntimeException(error.toString());
+  }
+
+  @Override
+  public void onOpCSRGenerationComplete(byte[] csr)
+  {
+    System.out.println("onOpCSRGenerationComplete");
+    for(int i=0; i< csr.length ; i++) {
+      System.out.print(csr[i] +" ");
+    }
+  }
+
+  public IPAddress GetRemoteAddr()
+  {
+    return mRemoteAddr;
+  }
 
   public PairingCommand(
       String commandName,
@@ -66,7 +176,7 @@ public PairingCommand(
     this.mFilterType = filterType;
 
     try {
-      this.mRemoteAddr = new IPAddress(InetAddress.getByName("0.0.0.0"));
+      this.mRemoteAddr = new IPAddress(InetAddress.getByName("127.0.0.1"));
     } catch (UnknownHostException e) {
       throw new RuntimeException(e);
     }
@@ -144,6 +254,7 @@ public PairingCommand(
         break;
     }
 
-    addArgument("timeout", (short) 0, Short.MAX_VALUE, mTimeout, null);
+    addArgument("timeout", (long) 0, Long.MAX_VALUE, mTimeoutMillis, null);
+
   }
 }
diff --git a/src/controller/java/AndroidDeviceControllerWrapper.cpp b/src/controller/java/AndroidDeviceControllerWrapper.cpp
index 80feffeeaeabd4..275ff3766cd734 100644
--- a/src/controller/java/AndroidDeviceControllerWrapper.cpp
+++ b/src/controller/java/AndroidDeviceControllerWrapper.cpp
@@ -38,8 +38,9 @@
 #include <lib/support/TestGroupData.h>
 #include <lib/support/ThreadOperationalDataset.h>
 #include <platform/KeyValueStoreManager.h>
+#ifndef JAVA_MATTER_CONTROLLER_TEST
 #include <platform/android/CHIPP256KeypairBridge.h>
-
+#endif // JAVA_MATTER_CONTROLLER_TEST
 using namespace chip;
 using namespace chip::Controller;
 using namespace chip::Credentials;
@@ -53,11 +54,13 @@ AndroidDeviceControllerWrapper::~AndroidDeviceControllerWrapper()
     }
     mController->Shutdown();
 
+#ifndef JAVA_MATTER_CONTROLLER_TEST
     if (mKeypairBridge != nullptr)
     {
         chip::Platform::Delete(mKeypairBridge);
         mKeypairBridge = nullptr;
     }
+#endif // JAVA_MATTER_CONTROLLER_TEST
 }
 
 void AndroidDeviceControllerWrapper::SetJavaObjectRef(JavaVM * vm, jobject obj)
@@ -75,7 +78,12 @@ void AndroidDeviceControllerWrapper::CallJavaMethod(const char * methodName, jin
 AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
     JavaVM * vm, jobject deviceControllerObj, chip::NodeId nodeId, chip::FabricId fabricId, const chip::CATValues & cats,
     chip::System::Layer * systemLayer, chip::Inet::EndPointManager<Inet::TCPEndPoint> * tcpEndPointManager,
-    chip::Inet::EndPointManager<Inet::UDPEndPoint> * udpEndPointManager, AndroidOperationalCredentialsIssuerPtr opCredsIssuerPtr,
+    chip::Inet::EndPointManager<Inet::UDPEndPoint> * udpEndPointManager, 
+    #ifdef JAVA_MATTER_CONTROLLER_TEST
+    ExampleOperationalCredentialsIssuerPtr opCredsIssuerPtr,
+    #else
+    AndroidOperationalCredentialsIssuerPtr opCredsIssuerPtr,
+    #endif
     jobject keypairDelegate, jbyteArray rootCertificate, jbyteArray intermediateCertificate, jbyteArray nodeOperationalCertificate,
     jbyteArray ipkEpochKey, uint16_t listenPort, uint16_t controllerVendorId, uint16_t failsafeTimerSeconds,
     bool attemptNetworkScanWiFi, bool attemptNetworkScanThread, bool skipCommissioningComplete, CHIP_ERROR * errInfoOnFailure)
@@ -124,11 +132,20 @@ AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
     std::unique_ptr<AndroidDeviceControllerWrapper> wrapper(
         new AndroidDeviceControllerWrapper(std::move(controller), std::move(opCredsIssuerPtr)));
 
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+    if (wrapper->mExampleStorage.Init() != CHIP_NO_ERROR)
+    {
+        ChipLogError(Controller, "Init Storage failure");
+        return nullptr;
+    }
+    chip::PersistentStorageDelegate * wrapperStorage = &wrapper->mExampleStorage;
+    wrapper->SetJavaObjectRef(vm, deviceControllerObj);
+    chip::Controller::ExampleOperationalCredentialsIssuer * opCredsIssuer = wrapper->mOpCredsIssuer.get();
+#else
     chip::PersistentStorageDelegate * wrapperStorage = wrapper.get();
-
     wrapper->SetJavaObjectRef(vm, deviceControllerObj);
-
     chip::Controller::AndroidOperationalCredentialsIssuer * opCredsIssuer = wrapper->mOpCredsIssuer.get();
+#endif
 
     // Initialize device attestation verifier
     // TODO: Replace testingRootStore with a AttestationTrustStore that has the necessary official PAA roots available
@@ -151,8 +168,8 @@ AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
     setupParams.pairingDelegate                = wrapper.get();
     setupParams.operationalCredentialsDelegate = opCredsIssuer;
     setupParams.defaultCommissioner            = &wrapper->mAutoCommissioner;
-    initParams.fabricIndependentStorage        = wrapperStorage;
 
+    initParams.fabricIndependentStorage        = wrapperStorage;
     wrapper->mGroupDataProvider.SetStorageDelegate(wrapperStorage);
 
     CommissioningParameters params = wrapper->mAutoCommissioner.GetCommissioningParameters();
@@ -169,7 +186,6 @@ AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
         return nullptr;
     }
     initParams.groupDataProvider = &wrapper->mGroupDataProvider;
-
     err = wrapper->mOpCertStore.Init(wrapperStorage);
     if (err != CHIP_NO_ERROR)
     {
@@ -177,9 +193,12 @@ AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
         return nullptr;
     }
     initParams.opCertStore = &wrapper->mOpCertStore;
-
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+    opCredsIssuer->Initialize(wrapper->mExampleStorage);
+#else
     // TODO: Init IPK Epoch Key in opcreds issuer, so that commissionees get the right IPK
     opCredsIssuer->Initialize(*wrapper.get(), &wrapper->mAutoCommissioner, wrapper.get()->mJavaObjectRef);
+#endif
 
     Platform::ScopedMemoryBuffer<uint8_t> noc;
     if (!noc.Alloc(kMaxCHIPDERCertLength))
@@ -208,7 +227,7 @@ AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
 
     // The lifetime of the ephemeralKey variable must be kept until SetupParams is saved.
     Crypto::P256Keypair ephemeralKey;
-
+#ifndef JAVA_MATTER_CONTROLLER_TEST
     if (rootCertificate != nullptr && nodeOperationalCertificate != nullptr && keypairDelegate != nullptr)
     {
         CHIPP256KeypairBridge * nativeKeypairBridge = wrapper->GetP256KeypairBridge();
@@ -245,6 +264,7 @@ AndroidDeviceControllerWrapper * AndroidDeviceControllerWrapper::AllocateNew(
         setupParams.controllerNOC  = chip::ByteSpan(wrapper->mNocCertificate.data(), wrapper->mNocCertificate.size());
     }
     else
+#endif // JAVA_MATTER_CONTROLLER_TEST
     {
         ChipLogProgress(Controller,
                         "No existing credentials provided: generating ephemeral local NOC chain with OperationalCredentialsIssuer");
diff --git a/src/controller/java/AndroidDeviceControllerWrapper.h b/src/controller/java/AndroidDeviceControllerWrapper.h
index c1421863bbf29d..1cd2eceec16a4f 100644
--- a/src/controller/java/AndroidDeviceControllerWrapper.h
+++ b/src/controller/java/AndroidDeviceControllerWrapper.h
@@ -29,10 +29,16 @@
 #include <credentials/PersistentStorageOpCertStore.h>
 #include <credentials/attestation_verifier/DacOnlyPartialAttestationVerifier.h>
 #include <lib/support/TimeUtils.h>
-#include <platform/android/CHIPP256KeypairBridge.h>
 #include <platform/internal/DeviceNetworkInfo.h>
 
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+#include <controller/ExampleOperationalCredentialsIssuer.h>
+#include <controller/ExamplePersistentStorage.h>
+#else
 #include "AndroidOperationalCredentialsIssuer.h"
+#include <platform/android/CHIPP256KeypairBridge.h>
+#include <platform/android/AndroidChipPlatform-JNI.h>
+#endif // JAVA_MATTER_CONTROLLER_TEST
 
 /**
  * This class contains all relevant information for the JNI view of CHIPDeviceController
@@ -50,6 +56,7 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
     jobject JavaObjectRef() { return mJavaObjectRef; }
     jlong ToJNIHandle();
 
+#ifndef JAVA_MATTER_CONTROLLER_TEST
     /**
      * Returns a CHIPP256KeypairBridge which can be used to delegate signing operations
      * to a KeypairDelegate in the Java layer. Note that this will always return a pointer
@@ -63,6 +70,7 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
         }
         return mKeypairBridge;
     }
+#endif // JAVA_MATTER_CONTROLLER_TEST
 
     void CallJavaMethod(const char * methodName, jint argument);
     CHIP_ERROR InitializeOperationalCredentialsIssuer();
@@ -108,7 +116,12 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
         return reinterpret_cast<AndroidDeviceControllerWrapper *>(handle);
     }
 
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+    using ExampleOperationalCredentialsIssuerPtr = std::unique_ptr<chip::Controller::ExampleOperationalCredentialsIssuer>;
+#else
     using AndroidOperationalCredentialsIssuerPtr = std::unique_ptr<chip::Controller::AndroidOperationalCredentialsIssuer>;
+#endif
+
 
     /**
      * Initializes a new CHIPDeviceController using the given parameters, and returns a pointer to the
@@ -147,12 +160,21 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
                 const chip::CATValues & cats, chip::System::Layer * systemLayer,
                 chip::Inet::EndPointManager<chip::Inet::TCPEndPoint> * tcpEndPointManager,
                 chip::Inet::EndPointManager<chip::Inet::UDPEndPoint> * udpEndPointManager,
-                AndroidOperationalCredentialsIssuerPtr opCredsIssuer, jobject keypairDelegate, jbyteArray rootCertificate,
+                #ifdef JAVA_MATTER_CONTROLLER_TEST
+                ExampleOperationalCredentialsIssuerPtr opCredsIssuer,
+                #else
+                AndroidOperationalCredentialsIssuerPtr opCredsIssuer,
+                #endif
+                jobject keypairDelegate, jbyteArray rootCertificate,
                 jbyteArray intermediateCertificate, jbyteArray nodeOperationalCertificate, jbyteArray ipkEpochKey,
                 uint16_t listenPort, uint16_t controllerVendorId, uint16_t failsafeTimerSeconds, bool attemptNetworkScanWiFi,
                 bool attemptNetworkScanThread, bool skipCommissioningComplete, CHIP_ERROR * errInfoOnFailure);
 
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+    chip::Controller::ExampleOperationalCredentialsIssuer * GetAndroidOperationalCredentialsIssuer()
+#else
     chip::Controller::AndroidOperationalCredentialsIssuer * GetAndroidOperationalCredentialsIssuer()
+#endif
     {
         return mOpCredsIssuer.get();
     }
@@ -161,7 +183,7 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
     using ChipDeviceControllerPtr = std::unique_ptr<chip::Controller::DeviceCommissioner>;
 
     ChipDeviceControllerPtr mController;
-    AndroidOperationalCredentialsIssuerPtr mOpCredsIssuer;
+
     // TODO: This may need to be injected as a GroupDataProvider*
     chip::Credentials::GroupDataProviderImpl mGroupDataProvider;
     // TODO: This may need to be injected as an OperationalCertificateStore *
@@ -169,7 +191,13 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
 
     JavaVM * mJavaVM                       = nullptr;
     jobject mJavaObjectRef                 = nullptr;
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+    ExampleOperationalCredentialsIssuerPtr mOpCredsIssuer;
+    PersistentStorage mExampleStorage;
+#else
+    AndroidOperationalCredentialsIssuerPtr mOpCredsIssuer;
     CHIPP256KeypairBridge * mKeypairBridge = nullptr;
+#endif // JAVA_MATTER_CONTROLLER_TEST
 
     // These fields allow us to release the string/byte array memory later.
     jstring ssidStr                    = nullptr;
@@ -187,7 +215,13 @@ class AndroidDeviceControllerWrapper : public chip::Controller::DevicePairingDel
 
     chip::Credentials::PartialDACVerifier mPartialDACVerifier;
 
-    AndroidDeviceControllerWrapper(ChipDeviceControllerPtr controller, AndroidOperationalCredentialsIssuerPtr opCredsIssuer) :
+    AndroidDeviceControllerWrapper(ChipDeviceControllerPtr controller,
+    #ifdef JAVA_MATTER_CONTROLLER_TEST
+    ExampleOperationalCredentialsIssuerPtr opCredsIssuer
+    #else
+    AndroidOperationalCredentialsIssuerPtr opCredsIssuer
+    #endif
+    ) :
         mController(std::move(controller)), mOpCredsIssuer(std::move(opCredsIssuer))
     {}
 };
diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn
index d7c68afd518800..4bc23ee9bc6638 100644
--- a/src/controller/java/BUILD.gn
+++ b/src/controller/java/BUILD.gn
@@ -55,6 +55,7 @@ shared_library("jni") {
       "${chip_root}/src/controller/ExamplePersistentStorage.h",
     ]
   }
+
   deps = [
     "${chip_root}/src/controller/data_model",
     "${chip_root}/src/controller/data_model:java-jni-sources",
diff --git a/src/controller/java/CHIPDeviceController-JNI.cpp b/src/controller/java/CHIPDeviceController-JNI.cpp
index ad606dc6d9534e..e898ff2793bcc2 100644
--- a/src/controller/java/CHIPDeviceController-JNI.cpp
+++ b/src/controller/java/CHIPDeviceController-JNI.cpp
@@ -52,7 +52,11 @@
 #include <system/SystemClock.h>
 #include <vector>
 
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+#include <controller/ExampleOperationalCredentialsIssuer.h>
+#else
 #include <platform/android/AndroidChipPlatform-JNI.h>
+#endif
 
 // Choose an approximation of PTHREAD_NULL if pthread.h doesn't define one.
 #ifndef PTHREAD_NULL
@@ -122,8 +126,10 @@ jint JNI_OnLoad(JavaVM * jvm, void * reserved)
     SuccessOrExit(err);
     ChipLogProgress(Controller, "Java class references loaded.");
 
+#ifndef JAVA_MATTER_CONTROLLER_TEST
     err = AndroidChipPlatformJNI_OnLoad(jvm, reserved);
     SuccessOrExit(err);
+#endif // JAVA_MATTER_CONTROLLER_TEST
 
 exit:
     if (err != CHIP_NO_ERROR)
@@ -237,6 +243,7 @@ JNI_METHOD(jint, onNOCChainGeneration)
     JniByteArray jByteArrayIcac(env, intermediateCertificate);
     JniByteArray jByteArrayNoc(env, operationalCertificate);
 
+#ifndef JAVA_MATTER_CONTROLLER_TEST
     err = wrapper->GetAndroidOperationalCredentialsIssuer()->NOCChainGenerated(CHIP_NO_ERROR, jByteArrayNoc.byteSpan(),
                                                                                jByteArrayIcac.byteSpan(), jByteArrayRcac.byteSpan(),
                                                                                ipkOptional, adminSubjectOptional);
@@ -245,6 +252,7 @@ JNI_METHOD(jint, onNOCChainGeneration)
     {
         ChipLogError(Controller, "Failed to SetNocChain for the device: %" CHIP_ERROR_FORMAT, err.Format());
     }
+#endif // JAVA_MATTER_CONTROLLER_TEST
     return err.AsInteger();
 }
 
@@ -332,8 +340,13 @@ JNI_METHOD(jlong, newDeviceController)(JNIEnv * env, jobject self, jobject contr
         bool skipCommissioningComplete     = env->CallBooleanMethod(controllerParams, getSkipCommissioningComplete);
         uint64_t adminSubject              = env->CallLongMethod(controllerParams, getAdminSubject);
 
+#ifdef JAVA_MATTER_CONTROLLER_TEST
+        std::unique_ptr<chip::Controller::ExampleOperationalCredentialsIssuer> opCredsIssuer(
+            new chip::Controller::ExampleOperationalCredentialsIssuer());
+#else
         std::unique_ptr<chip::Controller::AndroidOperationalCredentialsIssuer> opCredsIssuer(
-            new chip::Controller::AndroidOperationalCredentialsIssuer());
+            new chip::Controller::AndroidOperationalCredentialsIssuer())
+#endif
         wrapper = AndroidDeviceControllerWrapper::AllocateNew(
             sJVM, self, kLocalDeviceId, fabricId, chip::kUndefinedCATs, &DeviceLayer::SystemLayer(),
             DeviceLayer::TCPEndPointManager(), DeviceLayer::UDPEndPointManager(), std::move(opCredsIssuer), keypairDelegate,
@@ -554,7 +567,9 @@ JNI_METHOD(void, setUseJavaCallbackForNOCRequest)
     chip::DeviceLayer::StackLock lock;
     AndroidDeviceControllerWrapper * wrapper = AndroidDeviceControllerWrapper::FromJNIHandle(handle);
 
+#ifndef JAVA_MATTER_CONTROLLER_TEST
     wrapper->GetAndroidOperationalCredentialsIssuer()->SetUseJavaCallbackForNOCRequest(useCallback);
+#endif
 
     if (useCallback)
     {