AryaWu/sqlite

1#include "sqliteInt.h"2#include "unity.h"3#include <stdio.h>4#include <stdlib.h>5#include <string.h>6 7static sqlite3_int64 gPriorHard = 0;8static sqlite3_int64 gPriorSoft = 0;9 10void setUp(void) {11  /* Ensure SQLite is initialized so that mem0.mutex exists */12  int rc = sqlite3_initialize();13  TEST_ASSERT_EQUAL_INT_MESSAGE(SQLITE_OK, rc, "sqlite3_initialize failed");14 15  /* Snapshot current limits to restore in tearDown */16  gPriorHard = sqlite3_hard_heap_limit64(-1);17  gPriorSoft = sqlite3_soft_heap_limit64(-1);18}19 20void tearDown(void) {21  /* Restore prior hard first, then soft. The soft setter will clamp if needed. */22  (void)sqlite3_hard_heap_limit64(gPriorHard);23  (void)sqlite3_soft_heap_limit64(gPriorSoft);24}25 26/* Test that setting the hard limit returns the prior value and changes the limit */27void test_sqlite3_hard_heap_limit64_sets_and_returns_prior(void) {28  sqlite3_int64 startHard = sqlite3_hard_heap_limit64(-1);29 30  /* Set to 0 and verify return and current value */31  sqlite3_int64 prior1 = sqlite3_hard_heap_limit64(0);32  TEST_ASSERT_EQUAL_INT64(startHard, prior1);33  sqlite3_int64 now1 = sqlite3_hard_heap_limit64(-1);34  TEST_ASSERT_EQUAL_INT64(0, now1);35 36  /* Set to a positive value and verify */37  sqlite3_int64 newHard = (sqlite3_int64)123456;38  sqlite3_int64 prior2 = sqlite3_hard_heap_limit64(newHard);39  TEST_ASSERT_EQUAL_INT64(0, prior2);40  sqlite3_int64 now2 = sqlite3_hard_heap_limit64(-1);41  TEST_ASSERT_EQUAL_INT64(newHard, now2);42}43 44/* Test that a negative argument is a no-op and returns the current value */45void test_sqlite3_hard_heap_limit64_query_negative_no_change(void) {46  sqlite3_int64 current = sqlite3_hard_heap_limit64(-1);47  sqlite3_int64 ret = sqlite3_hard_heap_limit64(-42);48  TEST_ASSERT_EQUAL_INT64(current, ret);49  sqlite3_int64 after = sqlite3_hard_heap_limit64(-1);50  TEST_ASSERT_EQUAL_INT64(current, after);51}52 53/* Setting a hard limit when soft is disabled should activate soft to match hard */54void test_sqlite3_hard_heap_limit64_activates_soft_when_soft_disabled(void) {55  /* Ensure hard=0 and soft=0 */56  (void)sqlite3_hard_heap_limit64(0);57  (void)sqlite3_soft_heap_limit64(0);58  TEST_ASSERT_EQUAL_INT64(0, sqlite3_hard_heap_limit64(-1));59  TEST_ASSERT_EQUAL_INT64(0, sqlite3_soft_heap_limit64(-1));60 61  /* Now set hard to H, soft should become H as well */62  sqlite3_int64 H = (sqlite3_int64)(64 * 1024);63  (void)sqlite3_hard_heap_limit64(H);64 65  TEST_ASSERT_EQUAL_INT64(H, sqlite3_hard_heap_limit64(-1));66  TEST_ASSERT_EQUAL_INT64(H, sqlite3_soft_heap_limit64(-1));67}68 69/* Lowering the hard limit clamps the soft limit down to the new hard limit */70void test_sqlite3_hard_heap_limit64_lowering_hard_clamps_soft(void) {71  /* Disable hard, set a high soft */72  (void)sqlite3_hard_heap_limit64(0);73  sqlite3_int64 softHigh = (sqlite3_int64)(200 * 1024);74  (void)sqlite3_soft_heap_limit64(softHigh);75  TEST_ASSERT_EQUAL_INT64(softHigh, sqlite3_soft_heap_limit64(-1));76 77  /* Now lower hard to a smaller value; soft must be clamped to this */78  sqlite3_int64 newHard = (sqlite3_int64)(50 * 1024);79  (void)sqlite3_hard_heap_limit64(newHard);80 81  TEST_ASSERT_EQUAL_INT64(newHard, sqlite3_hard_heap_limit64(-1));82  TEST_ASSERT_EQUAL_INT64(newHard, sqlite3_soft_heap_limit64(-1));83}84 85/* Raising the hard limit above an existing non-zero soft limit does not increase soft */86void test_sqlite3_hard_heap_limit64_raising_hard_does_not_raise_soft(void) {87  /* Disable hard and set soft to a small value */88  (void)sqlite3_hard_heap_limit64(0);89  sqlite3_int64 softSmall = (sqlite3_int64)(8 * 1024);90  (void)sqlite3_soft_heap_limit64(softSmall);91  TEST_ASSERT_EQUAL_INT64(softSmall, sqlite3_soft_heap_limit64(-1));92 93  /* Now set hard to a larger value; soft should remain unchanged */94  sqlite3_int64 largerHard = (sqlite3_int64)(64 * 1024);95  (void)sqlite3_hard_heap_limit64(largerHard);96 97  TEST_ASSERT_EQUAL_INT64(largerHard, sqlite3_hard_heap_limit64(-1));98  TEST_ASSERT_EQUAL_INT64(softSmall, sqlite3_soft_heap_limit64(-1));99}100 101/* Attempting to set soft above hard gets clamped to hard */102void test_sqlite3_hard_heap_limit64_soft_set_above_hard_is_clamped(void) {103  sqlite3_int64 hard = (sqlite3_int64)(32 * 1024);104  (void)sqlite3_hard_heap_limit64(hard);105 106  /* Try to set soft above hard; should clamp to hard */107  sqlite3_int64 requestedSoft = (sqlite3_int64)(128 * 1024);108  (void)sqlite3_soft_heap_limit64(requestedSoft);109 110  TEST_ASSERT_EQUAL_INT64(hard, sqlite3_hard_heap_limit64(-1));111  TEST_ASSERT_EQUAL_INT64(hard, sqlite3_soft_heap_limit64(-1));112}113 114/* Disabling the hard limit (set to 0) also disables the soft limit (sets soft to 0) */115void test_sqlite3_hard_heap_limit64_disabling_sets_soft_to_zero(void) {116  /* Set a positive hard and soft */117  sqlite3_int64 hard = (sqlite3_int64)(96 * 1024);118  (void)sqlite3_hard_heap_limit64(hard);119  sqlite3_int64 soft = (sqlite3_int64)(64 * 1024);120  (void)sqlite3_soft_heap_limit64(soft);121  TEST_ASSERT_EQUAL_INT64(hard, sqlite3_hard_heap_limit64(-1));122  TEST_ASSERT_EQUAL_INT64(soft, sqlite3_soft_heap_limit64(-1));123 124  /* Disable hard -> soft should become 0 too */125  (void)sqlite3_hard_heap_limit64(0);126  TEST_ASSERT_EQUAL_INT64(0, sqlite3_hard_heap_limit64(-1));127  TEST_ASSERT_EQUAL_INT64(0, sqlite3_soft_heap_limit64(-1));128}129 130int main(void) {131  UNITY_BEGIN();132  RUN_TEST(test_sqlite3_hard_heap_limit64_sets_and_returns_prior);133  RUN_TEST(test_sqlite3_hard_heap_limit64_query_negative_no_change);134  RUN_TEST(test_sqlite3_hard_heap_limit64_activates_soft_when_soft_disabled);135  RUN_TEST(test_sqlite3_hard_heap_limit64_lowering_hard_clamps_soft);136  RUN_TEST(test_sqlite3_hard_heap_limit64_raising_hard_does_not_raise_soft);137  RUN_TEST(test_sqlite3_hard_heap_limit64_soft_set_above_hard_is_clamped);138  RUN_TEST(test_sqlite3_hard_heap_limit64_disabling_sets_soft_to_zero);139  return UNITY_END();140}