test(framework): consolidate and stabilize CredentialsTest (tronprotocol#6614)

* test(framework): merge duplicate CredentialsTest coverage

Consolidate the misplaced keystroe CredentialsTest into org.tron.keystore.CredentialsTest.

- remove the duplicate test under the misspelled keystroe package
- add explicit equals behavior coverage for address and cryptoEngine
- normalize assertions to JUnit Assert and remove legacy TestCase usage

* 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,25 +1,36 @@
 package org.tron.keystore;
 
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
-import junit.framework.TestCase;
-import lombok.extern.slf4j.Slf4j;
+import org.junit.Assert;
 import org.junit.Test;
-import org.springframework.util.Assert;
-import org.tron.common.crypto.SignUtils;
+import org.mockito.Mockito;
+import org.tron.common.crypto.SignInterface;
 import org.tron.common.crypto.sm2.SM2;
 import org.tron.common.utils.ByteUtil;
+import org.tron.common.utils.StringUtil;
 
-@Slf4j
-public class CredentialsTest extends TestCase {
+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.hasText(credentials.getAddress(),"Credentials address create failed!");
-    Assert.notNull(credentials.getSignInterface(),
-        "Credentials cryptoEngine create failed");
+  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
@@ -28,21 +39,43 @@ public void testCreateFromSM2() {
       Credentials.create(SM2.fromNodeId(ByteUtil.hexToBytes("fffffffffff"
           + "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
           + "fffffffffffffffffffffffffffffffffffffff")));
+      Assert.fail("Expected IllegalArgumentException");
     } catch (Exception e) {
-      Assert.isInstanceOf(IllegalArgumentException.class, e);
+      Assert.assertTrue(e instanceof IllegalArgumentException);
     }
   }
 
   @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));
-    Assert.isTrue(!credentials1.equals(credentials2),
-        "Credentials instance should be not equal!");
-    Assert.isTrue(!(credentials1.hashCode() == credentials2.hashCode()),
-        "Credentials instance hashcode should be not equal!");
+  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);
+  }
+
+  @Test
+  public void testEqualsWithAddressAndCryptoEngine() {
+    Object aObject = new Object();
+    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);
+    Credentials sameAddressDifferentEngineCredential = Credentials.create(signInterface2);
+    Credentials differentCredential = Credentials.create(signInterface3);
+
+    Assert.assertFalse(aObject.equals(credential));
+    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));
   }
 
-}
+}