test(vm): cover constant-call timeout policy and config

VmTimeoutPolicy: deadline math, max-of semantics (never shrink
below network), and cap-engagement gate against the runtime
network value. VmConfig: 0 sentinel, [80, 500] range, cap > 0.

Author: yanghang8612

common/src/test/java/org/tron/core/config/args/VmConfigTest.java

@@ -88,4 +88,66 @@ public void testEstimateEnergyMaxRetryBoundaryValues() {
     assertEquals(3, VmConfig.fromConfig(
         withRef("vm { estimateEnergyMaxRetry = 3 }")).getEstimateEnergyMaxRetry());
   }
+
+  // ===========================================================================
+  // Boundary tests for constant-call timeout (issue #6681)
+  // ===========================================================================
+
+  @Test
+  public void testConstantCallTimeoutDefaults() {
+    VmConfig vm = VmConfig.fromConfig(withRef());
+    assertEquals(0L, vm.getConstantCallTimeoutMs());
+    assertEquals(10, vm.getConstantCallMaxConcurrency());
+  }
+
+  @Test
+  public void testConstantCallTimeoutValidOverride() {
+    VmConfig vm = VmConfig.fromConfig(
+        withRef("vm { constantCallTimeoutMs = 200, constantCallMaxConcurrency = 4 }"));
+    assertEquals(200L, vm.getConstantCallTimeoutMs());
+    assertEquals(4, vm.getConstantCallMaxConcurrency());
+  }
+
+  @Test
+  public void testConstantCallTimeoutBoundaryValues() {
+    assertEquals(80L, VmConfig.fromConfig(
+        withRef("vm { constantCallTimeoutMs = 80 }")).getConstantCallTimeoutMs());
+    assertEquals(500L, VmConfig.fromConfig(
+        withRef("vm { constantCallTimeoutMs = 500 }")).getConstantCallTimeoutMs());
+    assertEquals(0L, VmConfig.fromConfig(
+        withRef("vm { constantCallTimeoutMs = 0 }")).getConstantCallTimeoutMs());
+  }
+
+  @Test
+  public void testConstantCallTimeoutBelowBaselineRejected() {
+    try {
+      VmConfig.fromConfig(withRef("vm { constantCallTimeoutMs = 50 }"));
+      org.junit.Assert.fail("expected IllegalArgumentException for ms < baseline");
+    } catch (IllegalArgumentException ex) {
+      org.junit.Assert.assertTrue(ex.getMessage(),
+          ex.getMessage().contains("constantCallTimeoutMs"));
+    }
+  }
+
+  @Test
+  public void testConstantCallTimeoutAboveMaxRejected() {
+    try {
+      VmConfig.fromConfig(withRef("vm { constantCallTimeoutMs = 1000 }"));
+      org.junit.Assert.fail("expected IllegalArgumentException for ms > max");
+    } catch (IllegalArgumentException ex) {
+      org.junit.Assert.assertTrue(ex.getMessage(),
+          ex.getMessage().contains("constantCallTimeoutMs"));
+    }
+  }
+
+  @Test
+  public void testConstantCallMaxConcurrencyZeroRejected() {
+    try {
+      VmConfig.fromConfig(withRef("vm { constantCallMaxConcurrency = 0 }"));
+      org.junit.Assert.fail("expected IllegalArgumentException for cap = 0");
+    } catch (IllegalArgumentException ex) {
+      org.junit.Assert.assertTrue(ex.getMessage(),
+          ex.getMessage().contains("constantCallMaxConcurrency"));
+    }
+  }
 }

common/src/test/java/org/tron/core/vm/VmTimeoutPolicyTest.java

@@ -0,0 +1,96 @@
+package org.tron.core.vm;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class VmTimeoutPolicyTest {
+
+  private static final long START = 1_000_000L; // arbitrary microseconds
+  private static final long MAX_CPU_MS = 80L;
+  private static final double RATIO = 1.0;
+
+  @Test
+  public void blockProcessingUsesMaxCpuTimes1000ByRatio() {
+    long deadline = VmTimeoutPolicy.computeVmShouldEndInUs(
+        false, START, MAX_CPU_MS, RATIO,
+        VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_UNSET);
+    assertEquals(START + 80_000L, deadline);
+  }
+
+  @Test
+  public void constantCallWithUnsetFallsBackToMaxCpu() {
+    long deadline = VmTimeoutPolicy.computeVmShouldEndInUs(
+        true, START, MAX_CPU_MS, RATIO,
+        VmTimeoutPolicy.CONSTANT_CALL_TIMEOUT_UNSET);
+    assertEquals(START + 80_000L, deadline);
+  }
+
+  @Test
+  public void constantCallWithOverrideUsesConfiguredTimeout() {
+    long deadline = VmTimeoutPolicy.computeVmShouldEndInUs(
+        true, START, MAX_CPU_MS, RATIO, 200L);
+    assertEquals(START + 200_000L, deadline);
+  }
+
+  @Test
+  public void constantCallNeverShrinksBelowNetwork() {
+    // Network raised to 100 ms (committee proposal), operator configures 80.
+    // Effective budget must remain at network value, not 80.
+    long deadline = VmTimeoutPolicy.computeVmShouldEndInUs(
+        true, START, 100L, RATIO, 80L);
+    assertEquals(START + 100_000L, deadline);
+  }
+
+  @Test
+  public void blockProcessingIgnoresConstantCallOverride() {
+    long deadline = VmTimeoutPolicy.computeVmShouldEndInUs(
+        false, START, MAX_CPU_MS, RATIO, 500L);
+    // Even if operator sets a long constant-call timeout, block processing
+    // remains gated by maxCpuTimeOfOneTx * ratio. Issue #6681 makes this
+    // a hard guarantee, not a convention.
+    assertEquals(START + 80_000L, deadline);
+  }
+
+  @Test
+  public void blockProcessingAppliesRatio() {
+    long deadline = VmTimeoutPolicy.computeVmShouldEndInUs(
+        false, START, MAX_CPU_MS, 0.5, 200L);
+    assertEquals(START + 40_000L, deadline);
+  }
+
+  // ===========================================================================
+  // Cap-engagement gate (issue #6681). The cap is engaged strictly when the
+  // operator's configured timeout exceeds the network's current
+  // maxCpuTimeOfOneTx; raising the network value shifts the threshold.
+  // ===========================================================================
+
+  @Test
+  public void capDisengagedAtSentinel() {
+    org.junit.Assert.assertFalse(VmTimeoutPolicy.isCapEngaged(0L, 80L));
+  }
+
+  @Test
+  public void capDisengagedWhenConfiguredEqualsNetwork() {
+    org.junit.Assert.assertFalse(VmTimeoutPolicy.isCapEngaged(80L, 80L));
+  }
+
+  @Test
+  public void capEngagedJustAboveNetwork() {
+    org.junit.Assert.assertTrue(VmTimeoutPolicy.isCapEngaged(81L, 80L));
+  }
+
+  @Test
+  public void capDisengagedWhenNetworkRaisedAboveConfigured() {
+    // Network committee raised maxCpuTimeOfOneTx to 100; operator's
+    // previously-set 80 is now below the network value -> no longer
+    // an "extension" -> cap stays disengaged.
+    org.junit.Assert.assertFalse(VmTimeoutPolicy.isCapEngaged(80L, 100L));
+  }
+
+  @Test
+  public void capEngagedAboveRaisedNetwork() {
+    // Network at 100; operator configures 120 to extend further -> cap on.
+    org.junit.Assert.assertTrue(VmTimeoutPolicy.isCapEngaged(120L, 100L));
+  }
+}