test(framework): stabilize CredentialsTest fixtures

Replace random Credentials test setup with deterministic SignInterface mocks
so the suite no longer depends on platform-specific SecureRandom providers or
probabilistic retries.

- remove NativePRNG usage from CredentialsTest
- replace random key generation with fixed address fixtures via mocked SignInterface
- assert create(SignInterface) returns the expected base58check address
- keep equals/hashCode contract coverage with deterministic inputs

Author: 3for

framework/src/test/java/org/tron/keystore/CredentialsTest.java

@@ -1,24 +1,36 @@
 package org.tron.keystore;
 
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
 import org.junit.Assert;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.tron.common.crypto.SignInterface;
-import org.tron.common.crypto.SignUtils;
 import org.tron.common.crypto.sm2.SM2;
 import org.tron.common.utils.ByteUtil;
+import org.tron.common.utils.StringUtil;
 
 public class CredentialsTest {
 
+  private static final byte[] ADDRESS_1 = ByteUtil.hexToBytes(
+      "410102030405060708090a0b0c0d0e0f1011121314");
+  private static final byte[] ADDRESS_2 = ByteUtil.hexToBytes(
+      "411415161718191a1b1c1d1e1f2021222324252627");
+
+  private SignInterface mockSignInterface(byte[] address) {
+    SignInterface signInterface = Mockito.mock(SignInterface.class);
+    Mockito.when(signInterface.getAddress()).thenReturn(address);
+    return signInterface;
+  }
+
   @Test
-  public void testCreate() throws NoSuchAlgorithmException {
-    Credentials credentials = Credentials.create(SignUtils.getGeneratedRandomSign(
-        SecureRandom.getInstance("NativePRNG"), true));
-    Assert.assertNotNull("Credentials address create failed!", credentials.getAddress());
-    Assert.assertFalse("Credentials address create failed!", credentials.getAddress().isEmpty());
-    Assert.assertNotNull("Credentials cryptoEngine create failed", credentials.getSignInterface());
+  public void testCreate() {
+    SignInterface signInterface = mockSignInterface(ADDRESS_1);
+
+    Credentials credentials = Credentials.create(signInterface);
+
+    Assert.assertEquals("Credentials address create failed!",
+        StringUtil.encode58Check(ADDRESS_1), credentials.getAddress());
+    Assert.assertSame("Credentials cryptoEngine create failed", signInterface,
+        credentials.getSignInterface());
   }
 
   @Test
@@ -34,28 +46,22 @@ public void testCreateFromSM2() {
   }
 
   @Test
-  public void testEquals() throws NoSuchAlgorithmException {
-    Credentials credentials1 = Credentials.create(SignUtils.getGeneratedRandomSign(
-        SecureRandom.getInstance("NativePRNG"), true));
-    Credentials credentials2 = Credentials.create(SignUtils.getGeneratedRandomSign(
-        SecureRandom.getInstance("NativePRNG"), true));
+  public void testEquals() {
+    Credentials credentials1 = Credentials.create(mockSignInterface(ADDRESS_1));
+    Credentials credentials2 = Credentials.create(mockSignInterface(ADDRESS_2));
+
+    Assert.assertNotEquals("Credentials address fixtures should differ",
+        credentials1.getAddress(), credentials2.getAddress());
     Assert.assertNotEquals("Credentials instance should be not equal!",
         credentials1, credentials2);
-    Assert.assertNotEquals("Credentials instance hashcode should be not equal!",
-        credentials1.hashCode(), credentials2.hashCode());
   }
 
   @Test
   public void testEqualsWithAddressAndCryptoEngine() {
     Object aObject = new Object();
-    SignInterface signInterface = Mockito.mock(SignInterface.class);
-    SignInterface signInterface2 = Mockito.mock(SignInterface.class);
-    SignInterface signInterface3 = Mockito.mock(SignInterface.class);
-    byte[] address = "TQhZ7W1RudxFdzJMw6FvMnujPxrS6sFfmj".getBytes();
-    byte[] address2 = "TNCmcTdyrYKMtmE1KU2itzeCX76jGm5Not".getBytes();
-    Mockito.when(signInterface.getAddress()).thenReturn(address);
-    Mockito.when(signInterface2.getAddress()).thenReturn(address);
-    Mockito.when(signInterface3.getAddress()).thenReturn(address2);
+    SignInterface signInterface = mockSignInterface(ADDRESS_1);
+    SignInterface signInterface2 = mockSignInterface(ADDRESS_1);
+    SignInterface signInterface3 = mockSignInterface(ADDRESS_2);
 
     Credentials credential = Credentials.create(signInterface);
     Credentials sameCredential = Credentials.create(signInterface);
@@ -66,6 +72,8 @@ public void testEqualsWithAddressAndCryptoEngine() {
     Assert.assertFalse(credential.equals(aObject));
     Assert.assertFalse(credential.equals(null));
     Assert.assertEquals(credential, sameCredential);
+    Assert.assertEquals("Equal credentials must have the same hashCode",
+        credential.hashCode(), sameCredential.hashCode());
     Assert.assertNotEquals(credential, sameAddressDifferentEngineCredential);
     Assert.assertFalse(credential.equals(differentCredential));
   }