diff --git a/src/test/modules/Makefile b/src/test/modules/Makefile
index 8a3cd2afab7..902a7954101 100644
--- a/src/test/modules/Makefile
+++ b/src/test/modules/Makefile
@@ -16,6 +16,7 @@ SUBDIRS = \
 		  spgist_name_ops \
 		  test_aio \
 		  test_binaryheap \
+		  test_bitmapset \
 		  test_bloomfilter \
 		  test_copy_callbacks \
 		  test_custom_rmgrs \
diff --git a/src/test/modules/meson.build b/src/test/modules/meson.build
index 717e85066ba..14fc761c4cf 100644
--- a/src/test/modules/meson.build
+++ b/src/test/modules/meson.build
@@ -15,6 +15,7 @@ subdir('spgist_name_ops')
 subdir('ssl_passphrase_callback')
 subdir('test_aio')
 subdir('test_binaryheap')
+subdir('test_bitmapset')
 subdir('test_bloomfilter')
 subdir('test_copy_callbacks')
 subdir('test_custom_rmgrs')
diff --git a/src/test/modules/test_bitmapset/.gitignore b/src/test/modules/test_bitmapset/.gitignore
new file mode 100644
index 00000000000..5dcb3ff9723
--- /dev/null
+++ b/src/test/modules/test_bitmapset/.gitignore
@@ -0,0 +1,4 @@
+# Generated subdirectories
+/log/
+/results/
+/tmp_check/
diff --git a/src/test/modules/test_bitmapset/Makefile b/src/test/modules/test_bitmapset/Makefile
new file mode 100644
index 00000000000..67199d40d73
--- /dev/null
+++ b/src/test/modules/test_bitmapset/Makefile
@@ -0,0 +1,23 @@
+# src/test/modules/test_bitmapset/Makefile
+
+MODULE_big = test_bitmapset
+OBJS = \
+	$(WIN32RES) \
+	test_bitmapset.o
+PGFILEDESC = "test_bitmapset - test code for src/include/nodes/bitmapset.h"
+
+EXTENSION = test_bitmapset
+DATA = test_bitmapset--1.0.sql
+
+REGRESS = test_bitmapset
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/test/modules/test_bitmapset
+top_builddir = ../../../..
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
diff --git a/src/test/modules/test_bitmapset/expected/test_bitmapset.out b/src/test/modules/test_bitmapset/expected/test_bitmapset.out
new file mode 100644
index 00000000000..ab255087416
--- /dev/null
+++ b/src/test/modules/test_bitmapset/expected/test_bitmapset.out
@@ -0,0 +1,621 @@
+CREATE EXTENSION IF NOT EXISTS test_bitmapset;
+-- make_singleton(42)
+SELECT test_bms_make_singleton(42) = '(b 42)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- make_singleton(0)
+SELECT test_bms_make_singleton(0) = '(b 0)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- make_singleton(1000)
+SELECT test_bms_make_singleton(1000) = '(b 1000)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_member(NULL, 10)
+SELECT test_bms_add_member('(b)', 10) = '(b 10)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_member consistency
+SELECT test_bms_add_member('(b)', 10) as result;
+ result 
+--------
+ (b 10)
+(1 row)
+
+-- add_member to existing
+SELECT test_bms_add_member('(b 5)', 10) = '(b 5 10)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_member sorted
+SELECT test_bms_add_member('(b 10)', 5) = '(b 5 10)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_member idempotent
+SELECT test_bms_add_member('(b 10)', 10) as result;
+ result 
+--------
+ (b 10)
+(1 row)
+
+-- del_member from NULL
+SELECT test_bms_del_member('(b)', 10) IS NULL as result;
+ result 
+--------
+ t
+(1 row)
+
+-- del_member singleton becomes empty
+SELECT test_bms_del_member('(b 10)', 10) IS NULL as result;
+ result 
+--------
+ t
+(1 row)
+
+-- del_member no change
+SELECT test_bms_del_member('(b 10)', 5) as result;
+ result 
+--------
+ (b 10)
+(1 row)
+
+-- del_member from middle
+SELECT test_bms_del_member('(b 1 2 3)', 2) = '(b 1 3)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- del_member triggers realloc
+SELECT test_bms_del_member(test_bms_del_member('(b 0 31 32 63 64)', 32), 63) as result;
+   result    
+-------------
+ (b 0 31 64)
+(1 row)
+
+-- del_member word boundary
+SELECT test_bms_del_member(test_bms_add_range('(b)', 30, 34), 32) as result;
+     result      
+-----------------
+ (b 30 31 33 34)
+(1 row)
+
+-- union operations
+SELECT 'union overlapping sets' as test,
+       test_bms_union('(b 1 3 5)', '(b 3 5 7)') = '(b 1 3 5 7)' as result
+UNION ALL
+SELECT 'union with NULL' as test,
+       test_bms_union('(b 1 3 5)', '(b)') = '(b 1 3 5)' as result
+UNION ALL
+SELECT 'union NULL with NULL' as test,
+       test_bms_union('(b)', '(b)') IS NULL as result;
+          test          | result 
+------------------------+--------
+ union overlapping sets | t
+ union with NULL        | t
+ union NULL with NULL   | t
+(3 rows)
+
+SELECT 'overlapping ranges' as test,
+       test_bms_union(
+           test_bms_add_range('(b)', 0, 15),
+           test_bms_add_range('(b)', 10, 20)
+       ) as result;
+        test        |                          result                          
+--------------------+----------------------------------------------------------
+ overlapping ranges | (b 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
+(1 row)
+
+-- intersection operations
+SELECT 'intersect overlapping sets' as test,
+       test_bms_intersect('(b 1 3 5)', '(b 3 5 7)') = '(b 3 5)' as result
+UNION ALL
+SELECT 'intersect disjoint sets' as test,
+       test_bms_intersect('(b 1 3 5)', '(b 2 4 6)') IS NULL as result
+UNION ALL
+SELECT 'intersect with NULL' as test,
+       test_bms_intersect('(b 1 3 5)', '(b)') IS NULL as result;
+            test            | result 
+----------------------------+--------
+ intersect overlapping sets | t
+ intersect disjoint sets    | t
+ intersect with NULL        | t
+(3 rows)
+
+-- bms_int_members
+SELECT 'int(ersect) overlapping sets' as test,
+       test_bms_int_members('(b 1 3 5)', '(b 3 5 7)') = '(b 3 5)' as result
+UNION ALL
+SELECT 'int(ersect) disjoint sets' as test,
+       test_bms_int_members('(b 1 3 5)', '(b 2 4 6)') IS NULL as result
+UNION ALL
+SELECT 'int(ersect) with NULL' as test,
+       test_bms_int_members('(b 1 3 5)', '(b)') IS NULL as result
+UNION ALL
+SELECT 'int(ersect) members' as test,
+	test_bms_int_members('(b 0 31 32 63 64)', '(b 31 32 64 65)') = '(b 31 32 64)' as result;
+             test             | result 
+------------------------------+--------
+ int(ersect) overlapping sets | t
+ int(ersect) disjoint sets    | t
+ int(ersect) with NULL        | t
+ int(ersect) members          | t
+(4 rows)
+
+-- difference operations
+SELECT 'difference overlapping sets' as test,
+       test_bms_difference('(b 1 3 5)', '(b 3 5 7)') = '(b 1)' as result
+UNION ALL
+SELECT 'difference disjoint sets' as test,
+       test_bms_difference('(b 1 3 5)', '(b 2 4 6)') = '(b 1 3 5)' as result
+UNION ALL
+SELECT 'difference identical sets' as test,
+       test_bms_difference('(b 1 3 5)', '(b 1 3 5)') IS NULL as result;
+            test             | result 
+-----------------------------+--------
+ difference overlapping sets | t
+ difference disjoint sets    | t
+ difference identical sets   | t
+(3 rows)
+
+SELECT 'difference subtraction edge case' as test,
+       test_bms_difference(
+           test_bms_add_range('(b)', 0, 100),
+           test_bms_add_range('(b)', 50, 150)
+       ) as result;
+               test               |                                                                     result                                                                      
+----------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------
+ difference subtraction edge case | (b 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49)
+(1 row)
+
+SELECT 'difference subtract to empty' as test,
+       test_bms_difference('(b 42)', '(b 42)') as result;
+             test             | result 
+------------------------------+--------
+ difference subtract to empty | 
+(1 row)
+
+-- membership tests
+SELECT 'is_member existing' as test, test_bms_is_member('(b 1 3 5)', 1) = true as result
+UNION ALL
+SELECT 'is_member missing' as test, test_bms_is_member('(b 1 3 5)', 2) = false as result
+UNION ALL
+SELECT 'is_member existing middle' as test, test_bms_is_member('(b 1 3 5)', 3) = true as result
+UNION ALL
+SELECT 'is_member NULL set' as test, test_bms_is_member('(b)', 1) = false as result;
+           test            | result 
+---------------------------+--------
+ is_member existing        | t
+ is_member missing         | t
+ is_member existing middle | t
+ is_member NULL set        | t
+(4 rows)
+
+-- num_members NULL
+SELECT test_bms_num_members('(b)') = 0 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- num_members small set
+SELECT test_bms_num_members('(b 1 3 5)') = 3 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- num_members larger set
+SELECT test_bms_num_members('(b 2 4 6 8 10)') = 5 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- set equality and comparison
+SELECT 'equal NULL NULL' as test, test_bms_equal('(b)', '(b)') = true as result
+UNION ALL
+SELECT 'equal NULL set' as test, test_bms_equal('(b)', '(b 1 3 5)') = false as result
+UNION ALL
+SELECT 'equal set NULL' as test, test_bms_equal('(b 1 3 5)', '(b)') = false as result
+UNION ALL
+SELECT 'equal identical sets' as test, test_bms_equal('(b 1 3 5)', '(b 1 3 5)') = true as result
+UNION ALL
+SELECT 'equal different sets' as test, test_bms_equal('(b 1 3 5)', '(b 2 4 6)') = false as result
+UNION ALL
+SELECT 'compare NULL NULL' as test, test_bms_compare('(b)', '(b)') = 0 as result
+UNION ALL
+SELECT 'compare NULL set' as test, test_bms_compare('(b)', '(b 1 3)') = -1 as result
+UNION ALL
+SELECT 'compare set NULL' as test, test_bms_compare('(b 1 3)', '(b)') = 1 as result
+UNION ALL
+SELECT 'compare equal sets' as test, test_bms_compare('(b 1 3)', '(b 1 3)') = 0 as result
+UNION ALL
+SELECT 'compare subset superset' as test, test_bms_compare('(b 1 3)', '(b 1 3 5)') = -1 as result
+UNION ALL
+SELECT 'compare superset subset' as test, test_bms_compare('(b 1 3 5)', '(b 1 3)') = 1 as result;
+          test           | result 
+-------------------------+--------
+ equal NULL NULL         | t
+ equal NULL set          | t
+ equal set NULL          | t
+ equal identical sets    | t
+ equal different sets    | t
+ compare NULL NULL       | t
+ compare NULL set        | t
+ compare set NULL        | t
+ compare equal sets      | t
+ compare subset superset | t
+ compare superset subset | t
+(11 rows)
+
+SELECT 'compare edge case' as test,
+       test_bms_compare(
+           test_bms_add_range('(b)', 0, 63),
+           test_bms_add_range('(b)', 0, 64)
+       ) as result;
+       test        | result 
+-------------------+--------
+ compare edge case |     -1
+(1 row)
+
+-- add_range basic
+SELECT test_bms_add_range('(b)', 5, 7) = '(b 5 6 7)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_range single element
+SELECT test_bms_add_range('(b)', 5, 5) = '(b 5)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_range to existing
+SELECT test_bms_add_range('(b 1 10)', 5, 7) = '(b 1 5 6 7 10)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_range at word boundary 31
+SELECT test_bms_add_range('(b)', 30, 34) as result;
+       result       
+--------------------
+ (b 30 31 32 33 34)
+(1 row)
+
+-- add_range at word boundary 63
+SELECT test_bms_add_range('(b)', 62, 66) as result;
+       result       
+--------------------
+ (b 62 63 64 65 66)
+(1 row)
+
+-- add_range large range
+SELECT length(test_bms_add_range('(b)', 0, 1000)) = 3898 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_range force realloc test 1
+SELECT length(test_bms_add_range('(b)', 0, 200)) = 697 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add_range foce realloc test 2
+SELECT length(test_bms_add_range('(b)', 1000, 1100)) = 508 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- membership empty
+SELECT test_bms_membership('(b)') = 0 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- membership singleton
+SELECT test_bms_membership('(b 42)') = 1 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- membership multiple
+SELECT test_bms_membership('(b 1 2)') = 2 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- singleton_member valid
+SELECT test_bms_singleton_member('(b 42)') = 42 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- set iteration
+SELECT 'next_member first' as test, test_bms_next_member('(b 5 10 15 20)', -1) = 5 as result
+UNION ALL
+SELECT 'next_member second' as test, test_bms_next_member('(b 5 10 15 20)', 5) = 10 as result
+UNION ALL
+SELECT 'next_member past end' as test, test_bms_next_member('(b 5 10 15 20)', 20) = -2 as result
+UNION ALL
+SELECT 'next_member empty set' as test, test_bms_next_member('(b)', -1) = -2 as result
+UNION ALL
+SELECT 'prev_member last' as test, test_bms_prev_member('(b 5 10 15 20)', 21) = 20 as result
+UNION ALL
+SELECT 'prev_member penultimate' as test, test_bms_prev_member('(b 5 10 15 20)', 20) = 15 as result
+UNION ALL
+SELECT 'prev_member past beginning' as test, test_bms_prev_member('(b 5 10 15 20)', 5) = -2 as result
+UNION ALL
+SELECT 'prev_member empty set' as test, test_bms_prev_member('(b)', 100) = -2 as result;
+            test            | result 
+----------------------------+--------
+ next_member first          | t
+ next_member second         | t
+ next_member past end       | t
+ next_member empty set      | t
+ prev_member last           | t
+ prev_member penultimate    | t
+ prev_member past beginning | t
+ prev_member empty set      | t
+(8 rows)
+
+-- hash functions
+SELECT 'hash NULL' as test, test_bms_hash_value('(b)') = 0 as result
+UNION ALL
+SELECT 'hash consistency' as test, test_bms_hash_value('(b 1 3 5)') = test_bms_hash_value('(b 1 3 5)')
+UNION ALL
+SELECT 'hash different sets' as test, test_bms_hash_value('(b 1 3 5)') != test_bms_hash_value('(b 2 4 6)');
+        test         | result 
+---------------------+--------
+ hash NULL           | t
+ hash consistency    | t
+ hash different sets | t
+(3 rows)
+
+-- set overlap
+SELECT 'overlap existing' as test, test_bms_overlap('(b 1 3 5)', '(b 3 5 7)') = true as result
+UNION ALL
+SELECT 'overlap none' as test, test_bms_overlap('(b 1 3 5)', '(b 2 4 6)') = false as result
+UNION ALL
+SELECT 'overlap with NULL' as test, test_bms_overlap('(b)', '(b 1 3 5)') = false as result;
+       test        | result 
+-------------------+--------
+ overlap existing  | t
+ overlap none      | t
+ overlap with NULL | t
+(3 rows)
+
+-- subset relations
+SELECT 'subset NULL is subset of all' as test, test_bms_is_subset('(b)', '(b 1 3 5)') = true as result
+UNION ALL
+SELECT 'subset proper subset' as test, test_bms_is_subset('(b 1 3)', '(b 1 3 5)') = true as result
+UNION ALL
+SELECT 'subset improper subset' as test, test_bms_is_subset('(b 1 3 5)', '(b 1 3)') = false as result
+UNION ALL
+SELECT 'subset disjoint sets' as test, test_bms_is_subset('(b 1 3)', '(b 2 4)') = false as result
+UNION ALL
+SELECT 'subset comparison edge' as test,
+	test_bms_is_subset(
+		test_bms_add_range(NULL, 0, 31),
+		test_bms_add_range(NULL, 0, 63))
+	= true as result;
+             test             | result 
+------------------------------+--------
+ subset NULL is subset of all | t
+ subset proper subset         | t
+ subset improper subset       | t
+ subset disjoint sets         | t
+ subset comparison edge       | t
+(5 rows)
+
+-- copy operations
+WITH test_set AS (SELECT '(b 1 3 5 7)' AS original)
+SELECT 'copy NULL' as test, test_bms_copy(NULL) IS NULL as result
+UNION ALL
+SELECT 'copy equality' as test, test_bms_equal(original, test_bms_copy(original)) = true as result FROM test_set;
+     test      | result 
+---------------+--------
+ copy NULL     | t
+ copy equality | t
+(2 rows)
+
+-- add members operation
+SELECT test_bms_add_members('(b 1 3)', '(b 5 7)') = '(b 1 3 5 7)' as result;
+ result 
+--------
+ t
+(1 row)
+
+-- add members complex
+SELECT test_bms_add_members('(b 1 3 5)', '(b 100 200 300)') as result;
+        result         
+-----------------------
+ (b 1 3 5 100 200 300)
+(1 row)
+
+-- hash consistency
+SELECT 'bitmap_hash NULL' as test,
+       test_bitmap_hash('(b)') = 0 as result
+UNION ALL
+SELECT 'bitmap_hash consistency' as test,
+       test_bitmap_hash('(b 1 3 5)') = test_bitmap_hash('(b 1 3 5)') as result
+UNION ALL
+SELECT 'bitmap_hash vs bms_hash_value' as test,
+       test_bitmap_hash('(b 1 3 5)') = test_bms_hash_value('(b 1 3 5)') as result
+UNION ALL
+SELECT 'bitmap_hash different sets' as test,
+       test_bitmap_hash('(b 1 3 5)') != test_bitmap_hash('(b 2 4 6)') as result;
+             test              | result 
+-------------------------------+--------
+ bitmap_hash NULL              | t
+ bitmap_hash consistency       | t
+ bitmap_hash vs bms_hash_value | t
+ bitmap_hash different sets    | t
+(4 rows)
+
+-- match function
+SELECT 'bitmap_match NULL NULL (should be 0)' as test,
+       test_bitmap_match('(b)', '(b)') = 0 as result
+UNION ALL
+SELECT 'bitmap_match NULL set (should be 1)' as test,
+       test_bitmap_match('(b)', '(b 1 3 5)') = 1 as result
+UNION ALL
+SELECT 'bitmap_match set NULL (should be 1)' as test,
+       test_bitmap_match('(b 1 3 5)', '(b)') = 1 as result
+UNION ALL
+SELECT 'bitmap_match identical sets (should be 0)' as test,
+       test_bitmap_match('(b 1 3 5)', '(b 1 3 5)') = 0 as result
+UNION ALL
+SELECT 'bitmap_match different sets (should be 1)' as test,
+       test_bitmap_match('(b 1 3 5)', '(b 2 4 6)') = 1 as result
+UNION ALL
+SELECT 'bitmap_match subset/superset (should be 1)' as test,
+       test_bitmap_match('(b 1 3)', '(b 1 3 5)') = 1 as result;
+                    test                    | result 
+--------------------------------------------+--------
+ bitmap_match NULL NULL (should be 0)       | t
+ bitmap_match NULL set (should be 1)        | t
+ bitmap_match set NULL (should be 1)        | t
+ bitmap_match identical sets (should be 0)  | t
+ bitmap_match different sets (should be 1)  | t
+ bitmap_match subset/superset (should be 1) | t
+(6 rows)
+
+-- match relationship with bms_equal
+SELECT 'bitmap_match vs bms_equal (equal sets)' as test,
+       (test_bitmap_match('(b 1 3 5)', '(b 1 3 5)') = 0) = test_bms_equal('(b 1 3 5)', '(b 1 3 5)') as result
+UNION ALL
+SELECT 'bitmap_match vs bms_equal (different sets)' as test,
+       (test_bitmap_match('(b 1 3 5)', '(b 2 4 6)') = 0) = test_bms_equal('(b 1 3 5)', '(b 2 4 6)') as result
+UNION ALL
+SELECT 'bitmap_match vs bms_equal (NULL cases)' as test,
+       (test_bitmap_match('(b)', '(b)') = 0) = test_bms_equal('(b)', '(b)') as result;
+                    test                    | result 
+--------------------------------------------+--------
+ bitmap_match vs bms_equal (equal sets)     | t
+ bitmap_match vs bms_equal (different sets) | t
+ bitmap_match vs bms_equal (NULL cases)     | t
+(3 rows)
+
+-- bitmap_match [1,3,5] vs [1,3,5]
+SELECT test_bitmap_match('(b 1 3 5)', '(b 1 3 5)') as match_value;
+ match_value 
+-------------
+           0
+(1 row)
+
+-- bitmap_match [1,3,5] vs [2,4,6]
+SELECT test_bitmap_match('(b 1 3 5)', '(b 2 4 6)') as match_value;
+ match_value 
+-------------
+           1
+(1 row)
+
+-- bitmap_match empty arrays
+SELECT test_bitmap_match('(b)', '(b)') = 0 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- overlap with lists
+WITH test_lists AS (
+    SELECT
+        ARRAY[0] AS a0,
+        ARRAY[1,2] AS a12,
+        ARRAY[3,4,5] AS a345,
+        ARRAY[6,7,8,9] AS a6789
+)
+SELECT 'overlap list 0' as test,
+       test_bms_overlap_list('(b 0)', a0) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 12' as test,
+       test_bms_overlap_list('(b 2 3)', a12) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 345' as test,
+       test_bms_overlap_list('(b 3 4)', a345) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 6789' as test,
+       test_bms_overlap_list('(b 7 10)', a6789) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 6789 no overlap' as test,
+       test_bms_overlap_list('(b 1 5)', a6789) as result
+FROM test_lists;
+             test             | result 
+------------------------------+--------
+ overlap list 0               | t
+ overlap list 12              | t
+ overlap list 345             | t
+ overlap list 6789            | t
+ overlap list 6789 no overlap | f
+(5 rows)
+
+-- overlap empty list
+SELECT test_bms_overlap_list('(b 1)', ARRAY[]::integer[]) as result;
+ result 
+--------
+ f
+(1 row)
+
+-- random operations
+SELECT test_random_operations(-1, 10000, 81920, 0) > 0 as result;
+ result 
+--------
+ t
+(1 row)
+
+-- these should produce ERRORs
+SELECT test_bms_make_singleton(-1);
+ERROR:  negative bitmapset member not allowed
+SELECT test_bms_add_member('(b 1)', -1);
+ERROR:  negative bitmapset member not allowed
+SELECT test_bms_is_member('(b)', -5);
+ERROR:  negative bitmapset member not allowed
+SELECT test_bms_add_member('(b)', -10);
+ERROR:  negative bitmapset member not allowed
+SELECT test_bms_del_member('(b)', -20);
+ERROR:  negative bitmapset member not allowed
+SELECT test_bms_add_range('(b)', -5, 10);
+ERROR:  negative bitmapset member not allowed
+SELECT test_bms_singleton_member('(b 1 2)');
+ERROR:  bitmapset has multiple members
+SELECT test_bms_add_member('(b)', 1000);
+ test_bms_add_member 
+---------------------
+ (b 1000)
+(1 row)
+
+DROP EXTENSION test_bitmapset;
diff --git a/src/test/modules/test_bitmapset/meson.build b/src/test/modules/test_bitmapset/meson.build
new file mode 100644
index 00000000000..848f7a44eb9
--- /dev/null
+++ b/src/test/modules/test_bitmapset/meson.build
@@ -0,0 +1,33 @@
+# Copyright (c) 2024-2025, PostgreSQL Global Development Group
+
+test_bitmapset_sources = files(
+  'test_bitmapset.c',
+)
+
+if host_system == 'windows'
+  test_bitmapset_sources += rc_lib_gen.process(win32ver_rc, extra_args: [
+    '--NAME', 'test_bitmapset',
+    '--FILEDESC', 'test_bitmapset - test code for src/include/nodes/bitmapset.h',])
+endif
+
+test_bitmapset = shared_module('test_bitmapset',
+  test_bitmapset_sources,
+  kwargs: pg_test_mod_args,
+)
+test_install_libs += test_bitmapset
+
+test_install_data += files(
+  'test_bitmapset.control',
+  'test_bitmapset--1.0.sql',
+)
+
+tests += {
+  'name': 'test_bitmapset',
+  'sd': meson.current_source_dir(),
+  'bd': meson.current_build_dir(),
+  'regress': {
+    'sql': [
+      'test_bitmapset',
+    ],
+  },
+}
diff --git a/src/test/modules/test_bitmapset/sql/test_bitmapset.sql b/src/test/modules/test_bitmapset/sql/test_bitmapset.sql
new file mode 100644
index 00000000000..c80e6193219
--- /dev/null
+++ b/src/test/modules/test_bitmapset/sql/test_bitmapset.sql
@@ -0,0 +1,312 @@
+CREATE EXTENSION IF NOT EXISTS test_bitmapset;
+
+-- make_singleton(42)
+SELECT test_bms_make_singleton(42) = '(b 42)' as result;
+-- make_singleton(0)
+SELECT test_bms_make_singleton(0) = '(b 0)' as result;
+-- make_singleton(1000)
+SELECT test_bms_make_singleton(1000) = '(b 1000)' as result;
+
+-- add_member(NULL, 10)
+SELECT test_bms_add_member('(b)', 10) = '(b 10)' as result;
+-- add_member consistency
+SELECT test_bms_add_member('(b)', 10) as result;
+-- add_member to existing
+SELECT test_bms_add_member('(b 5)', 10) = '(b 5 10)' as result;
+-- add_member sorted
+SELECT test_bms_add_member('(b 10)', 5) = '(b 5 10)' as result;
+-- add_member idempotent
+SELECT test_bms_add_member('(b 10)', 10) as result;
+
+
+-- del_member from NULL
+SELECT test_bms_del_member('(b)', 10) IS NULL as result;
+-- del_member singleton becomes empty
+SELECT test_bms_del_member('(b 10)', 10) IS NULL as result;
+-- del_member no change
+SELECT test_bms_del_member('(b 10)', 5) as result;
+-- del_member from middle
+SELECT test_bms_del_member('(b 1 2 3)', 2) = '(b 1 3)' as result;
+-- del_member triggers realloc
+SELECT test_bms_del_member(test_bms_del_member('(b 0 31 32 63 64)', 32), 63) as result;
+-- del_member word boundary
+SELECT test_bms_del_member(test_bms_add_range('(b)', 30, 34), 32) as result;
+
+-- union operations
+SELECT 'union overlapping sets' as test,
+       test_bms_union('(b 1 3 5)', '(b 3 5 7)') = '(b 1 3 5 7)' as result
+UNION ALL
+SELECT 'union with NULL' as test,
+       test_bms_union('(b 1 3 5)', '(b)') = '(b 1 3 5)' as result
+UNION ALL
+SELECT 'union NULL with NULL' as test,
+       test_bms_union('(b)', '(b)') IS NULL as result;
+SELECT 'overlapping ranges' as test,
+       test_bms_union(
+           test_bms_add_range('(b)', 0, 15),
+           test_bms_add_range('(b)', 10, 20)
+       ) as result;
+
+-- intersection operations
+SELECT 'intersect overlapping sets' as test,
+       test_bms_intersect('(b 1 3 5)', '(b 3 5 7)') = '(b 3 5)' as result
+UNION ALL
+SELECT 'intersect disjoint sets' as test,
+       test_bms_intersect('(b 1 3 5)', '(b 2 4 6)') IS NULL as result
+UNION ALL
+SELECT 'intersect with NULL' as test,
+       test_bms_intersect('(b 1 3 5)', '(b)') IS NULL as result;
+
+-- bms_int_members
+SELECT 'int(ersect) overlapping sets' as test,
+       test_bms_int_members('(b 1 3 5)', '(b 3 5 7)') = '(b 3 5)' as result
+UNION ALL
+SELECT 'int(ersect) disjoint sets' as test,
+       test_bms_int_members('(b 1 3 5)', '(b 2 4 6)') IS NULL as result
+UNION ALL
+SELECT 'int(ersect) with NULL' as test,
+       test_bms_int_members('(b 1 3 5)', '(b)') IS NULL as result
+UNION ALL
+SELECT 'int(ersect) members' as test,
+	test_bms_int_members('(b 0 31 32 63 64)', '(b 31 32 64 65)') = '(b 31 32 64)' as result;
+
+-- difference operations
+SELECT 'difference overlapping sets' as test,
+       test_bms_difference('(b 1 3 5)', '(b 3 5 7)') = '(b 1)' as result
+UNION ALL
+SELECT 'difference disjoint sets' as test,
+       test_bms_difference('(b 1 3 5)', '(b 2 4 6)') = '(b 1 3 5)' as result
+UNION ALL
+SELECT 'difference identical sets' as test,
+       test_bms_difference('(b 1 3 5)', '(b 1 3 5)') IS NULL as result;
+SELECT 'difference subtraction edge case' as test,
+       test_bms_difference(
+           test_bms_add_range('(b)', 0, 100),
+           test_bms_add_range('(b)', 50, 150)
+       ) as result;
+SELECT 'difference subtract to empty' as test,
+       test_bms_difference('(b 42)', '(b 42)') as result;
+
+-- membership tests
+SELECT 'is_member existing' as test, test_bms_is_member('(b 1 3 5)', 1) = true as result
+UNION ALL
+SELECT 'is_member missing' as test, test_bms_is_member('(b 1 3 5)', 2) = false as result
+UNION ALL
+SELECT 'is_member existing middle' as test, test_bms_is_member('(b 1 3 5)', 3) = true as result
+UNION ALL
+SELECT 'is_member NULL set' as test, test_bms_is_member('(b)', 1) = false as result;
+
+-- num_members NULL
+SELECT test_bms_num_members('(b)') = 0 as result;
+-- num_members small set
+SELECT test_bms_num_members('(b 1 3 5)') = 3 as result;
+-- num_members larger set
+SELECT test_bms_num_members('(b 2 4 6 8 10)') = 5 as result;
+
+-- set equality and comparison
+SELECT 'equal NULL NULL' as test, test_bms_equal('(b)', '(b)') = true as result
+UNION ALL
+SELECT 'equal NULL set' as test, test_bms_equal('(b)', '(b 1 3 5)') = false as result
+UNION ALL
+SELECT 'equal set NULL' as test, test_bms_equal('(b 1 3 5)', '(b)') = false as result
+UNION ALL
+SELECT 'equal identical sets' as test, test_bms_equal('(b 1 3 5)', '(b 1 3 5)') = true as result
+UNION ALL
+SELECT 'equal different sets' as test, test_bms_equal('(b 1 3 5)', '(b 2 4 6)') = false as result
+UNION ALL
+SELECT 'compare NULL NULL' as test, test_bms_compare('(b)', '(b)') = 0 as result
+UNION ALL
+SELECT 'compare NULL set' as test, test_bms_compare('(b)', '(b 1 3)') = -1 as result
+UNION ALL
+SELECT 'compare set NULL' as test, test_bms_compare('(b 1 3)', '(b)') = 1 as result
+UNION ALL
+SELECT 'compare equal sets' as test, test_bms_compare('(b 1 3)', '(b 1 3)') = 0 as result
+UNION ALL
+SELECT 'compare subset superset' as test, test_bms_compare('(b 1 3)', '(b 1 3 5)') = -1 as result
+UNION ALL
+SELECT 'compare superset subset' as test, test_bms_compare('(b 1 3 5)', '(b 1 3)') = 1 as result;
+SELECT 'compare edge case' as test,
+       test_bms_compare(
+           test_bms_add_range('(b)', 0, 63),
+           test_bms_add_range('(b)', 0, 64)
+       ) as result;
+
+-- add_range basic
+SELECT test_bms_add_range('(b)', 5, 7) = '(b 5 6 7)' as result;
+-- add_range single element
+SELECT test_bms_add_range('(b)', 5, 5) = '(b 5)' as result;
+-- add_range to existing
+SELECT test_bms_add_range('(b 1 10)', 5, 7) = '(b 1 5 6 7 10)' as result;
+-- add_range at word boundary 31
+SELECT test_bms_add_range('(b)', 30, 34) as result;
+-- add_range at word boundary 63
+SELECT test_bms_add_range('(b)', 62, 66) as result;
+-- add_range large range
+SELECT length(test_bms_add_range('(b)', 0, 1000)) = 3898 as result;
+-- add_range force realloc test 1
+SELECT length(test_bms_add_range('(b)', 0, 200)) = 697 as result;
+-- add_range foce realloc test 2
+SELECT length(test_bms_add_range('(b)', 1000, 1100)) = 508 as result;
+
+-- membership empty
+SELECT test_bms_membership('(b)') = 0 as result;
+-- membership singleton
+SELECT test_bms_membership('(b 42)') = 1 as result;
+-- membership multiple
+SELECT test_bms_membership('(b 1 2)') = 2 as result;
+
+-- singleton_member valid
+SELECT test_bms_singleton_member('(b 42)') = 42 as result;
+
+-- set iteration
+SELECT 'next_member first' as test, test_bms_next_member('(b 5 10 15 20)', -1) = 5 as result
+UNION ALL
+SELECT 'next_member second' as test, test_bms_next_member('(b 5 10 15 20)', 5) = 10 as result
+UNION ALL
+SELECT 'next_member past end' as test, test_bms_next_member('(b 5 10 15 20)', 20) = -2 as result
+UNION ALL
+SELECT 'next_member empty set' as test, test_bms_next_member('(b)', -1) = -2 as result
+UNION ALL
+SELECT 'prev_member last' as test, test_bms_prev_member('(b 5 10 15 20)', 21) = 20 as result
+UNION ALL
+SELECT 'prev_member penultimate' as test, test_bms_prev_member('(b 5 10 15 20)', 20) = 15 as result
+UNION ALL
+SELECT 'prev_member past beginning' as test, test_bms_prev_member('(b 5 10 15 20)', 5) = -2 as result
+UNION ALL
+SELECT 'prev_member empty set' as test, test_bms_prev_member('(b)', 100) = -2 as result;
+
+-- hash functions
+SELECT 'hash NULL' as test, test_bms_hash_value('(b)') = 0 as result
+UNION ALL
+SELECT 'hash consistency' as test, test_bms_hash_value('(b 1 3 5)') = test_bms_hash_value('(b 1 3 5)')
+UNION ALL
+SELECT 'hash different sets' as test, test_bms_hash_value('(b 1 3 5)') != test_bms_hash_value('(b 2 4 6)');
+
+-- set overlap
+SELECT 'overlap existing' as test, test_bms_overlap('(b 1 3 5)', '(b 3 5 7)') = true as result
+UNION ALL
+SELECT 'overlap none' as test, test_bms_overlap('(b 1 3 5)', '(b 2 4 6)') = false as result
+UNION ALL
+SELECT 'overlap with NULL' as test, test_bms_overlap('(b)', '(b 1 3 5)') = false as result;
+
+-- subset relations
+SELECT 'subset NULL is subset of all' as test, test_bms_is_subset('(b)', '(b 1 3 5)') = true as result
+UNION ALL
+SELECT 'subset proper subset' as test, test_bms_is_subset('(b 1 3)', '(b 1 3 5)') = true as result
+UNION ALL
+SELECT 'subset improper subset' as test, test_bms_is_subset('(b 1 3 5)', '(b 1 3)') = false as result
+UNION ALL
+SELECT 'subset disjoint sets' as test, test_bms_is_subset('(b 1 3)', '(b 2 4)') = false as result
+UNION ALL
+SELECT 'subset comparison edge' as test,
+	test_bms_is_subset(
+		test_bms_add_range(NULL, 0, 31),
+		test_bms_add_range(NULL, 0, 63))
+	= true as result;
+
+-- copy operations
+WITH test_set AS (SELECT '(b 1 3 5 7)' AS original)
+SELECT 'copy NULL' as test, test_bms_copy(NULL) IS NULL as result
+UNION ALL
+SELECT 'copy equality' as test, test_bms_equal(original, test_bms_copy(original)) = true as result FROM test_set;
+
+-- add members operation
+SELECT test_bms_add_members('(b 1 3)', '(b 5 7)') = '(b 1 3 5 7)' as result;
+-- add members complex
+SELECT test_bms_add_members('(b 1 3 5)', '(b 100 200 300)') as result;
+
+-- hash consistency
+SELECT 'bitmap_hash NULL' as test,
+       test_bitmap_hash('(b)') = 0 as result
+UNION ALL
+SELECT 'bitmap_hash consistency' as test,
+       test_bitmap_hash('(b 1 3 5)') = test_bitmap_hash('(b 1 3 5)') as result
+UNION ALL
+SELECT 'bitmap_hash vs bms_hash_value' as test,
+       test_bitmap_hash('(b 1 3 5)') = test_bms_hash_value('(b 1 3 5)') as result
+UNION ALL
+SELECT 'bitmap_hash different sets' as test,
+       test_bitmap_hash('(b 1 3 5)') != test_bitmap_hash('(b 2 4 6)') as result;
+
+-- match function
+SELECT 'bitmap_match NULL NULL (should be 0)' as test,
+       test_bitmap_match('(b)', '(b)') = 0 as result
+UNION ALL
+SELECT 'bitmap_match NULL set (should be 1)' as test,
+       test_bitmap_match('(b)', '(b 1 3 5)') = 1 as result
+UNION ALL
+SELECT 'bitmap_match set NULL (should be 1)' as test,
+       test_bitmap_match('(b 1 3 5)', '(b)') = 1 as result
+UNION ALL
+SELECT 'bitmap_match identical sets (should be 0)' as test,
+       test_bitmap_match('(b 1 3 5)', '(b 1 3 5)') = 0 as result
+UNION ALL
+SELECT 'bitmap_match different sets (should be 1)' as test,
+       test_bitmap_match('(b 1 3 5)', '(b 2 4 6)') = 1 as result
+UNION ALL
+SELECT 'bitmap_match subset/superset (should be 1)' as test,
+       test_bitmap_match('(b 1 3)', '(b 1 3 5)') = 1 as result;
+
+-- match relationship with bms_equal
+SELECT 'bitmap_match vs bms_equal (equal sets)' as test,
+       (test_bitmap_match('(b 1 3 5)', '(b 1 3 5)') = 0) = test_bms_equal('(b 1 3 5)', '(b 1 3 5)') as result
+UNION ALL
+SELECT 'bitmap_match vs bms_equal (different sets)' as test,
+       (test_bitmap_match('(b 1 3 5)', '(b 2 4 6)') = 0) = test_bms_equal('(b 1 3 5)', '(b 2 4 6)') as result
+UNION ALL
+SELECT 'bitmap_match vs bms_equal (NULL cases)' as test,
+       (test_bitmap_match('(b)', '(b)') = 0) = test_bms_equal('(b)', '(b)') as result;
+
+-- bitmap_match [1,3,5] vs [1,3,5]
+SELECT test_bitmap_match('(b 1 3 5)', '(b 1 3 5)') as match_value;
+-- bitmap_match [1,3,5] vs [2,4,6]
+SELECT test_bitmap_match('(b 1 3 5)', '(b 2 4 6)') as match_value;
+
+-- bitmap_match empty arrays
+SELECT test_bitmap_match('(b)', '(b)') = 0 as result;
+
+-- overlap with lists
+WITH test_lists AS (
+    SELECT
+        ARRAY[0] AS a0,
+        ARRAY[1,2] AS a12,
+        ARRAY[3,4,5] AS a345,
+        ARRAY[6,7,8,9] AS a6789
+)
+SELECT 'overlap list 0' as test,
+       test_bms_overlap_list('(b 0)', a0) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 12' as test,
+       test_bms_overlap_list('(b 2 3)', a12) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 345' as test,
+       test_bms_overlap_list('(b 3 4)', a345) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 6789' as test,
+       test_bms_overlap_list('(b 7 10)', a6789) as result
+FROM test_lists
+UNION ALL
+SELECT 'overlap list 6789 no overlap' as test,
+       test_bms_overlap_list('(b 1 5)', a6789) as result
+FROM test_lists;
+
+-- overlap empty list
+SELECT test_bms_overlap_list('(b 1)', ARRAY[]::integer[]) as result;
+
+-- random operations
+SELECT test_random_operations(-1, 10000, 81920, 0) > 0 as result;
+
+-- these should produce ERRORs
+SELECT test_bms_make_singleton(-1);
+SELECT test_bms_add_member('(b 1)', -1);
+SELECT test_bms_is_member('(b)', -5);
+SELECT test_bms_add_member('(b)', -10);
+SELECT test_bms_del_member('(b)', -20);
+SELECT test_bms_add_range('(b)', -5, 10);
+SELECT test_bms_singleton_member('(b 1 2)');
+SELECT test_bms_add_member('(b)', 1000);
+
+DROP EXTENSION test_bitmapset;
diff --git a/src/test/modules/test_bitmapset/test_bitmapset--1.0.sql b/src/test/modules/test_bitmapset/test_bitmapset--1.0.sql
new file mode 100644
index 00000000000..95f5ee02e3f
--- /dev/null
+++ b/src/test/modules/test_bitmapset/test_bitmapset--1.0.sql
@@ -0,0 +1,136 @@
+/* src/test/modules/test_bitmapset/test_bitmapset--1.0.sql */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION test_bitmapset" to load this file. \quit
+
+-- Bitmapset API functions
+CREATE FUNCTION test_bms_make_singleton(integer)
+RETURNS text STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_add_member(text, integer)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_del_member(text, integer)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_is_member(text, integer)
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_num_members(text)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_copy(text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_equal(text, text)
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_compare(text, text)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_is_subset(text, text)
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_subset_compare(text, text)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_union(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_intersect(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_difference(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_is_empty(text)
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_membership(text)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_singleton_member(text)
+RETURNS integer STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_get_singleton_member(text, integer)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_next_member(text, integer)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_prev_member(text, integer)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_hash_value(text)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_overlap(text, text)
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_overlap_list(text, int4[])
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_nonempty_difference(text, text)
+RETURNS boolean
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_member_index(text, integer)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_add_range(text, integer, integer)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_add_members(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_int_members(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_replace_members(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bms_join(text, text)
+RETURNS text
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bitmap_hash(text)
+RETURNS integer
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION test_bitmap_match(text, text)
+RETURNS int
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+-- Test utility functions
+CREATE FUNCTION test_random_operations(integer, integer, integer, integer)
+RETURNS integer STRICT
+AS 'MODULE_PATHNAME' LANGUAGE C;
+
+COMMENT ON EXTENSION test_bitmapset IS 'Test code for Bitmapset';
diff --git a/src/test/modules/test_bitmapset/test_bitmapset.c b/src/test/modules/test_bitmapset/test_bitmapset.c
new file mode 100644
index 00000000000..d1c74807ec1
--- /dev/null
+++ b/src/test/modules/test_bitmapset/test_bitmapset.c
@@ -0,0 +1,1008 @@
+/*
+ * test_bitmapset.c
+ *      Test module for bitmapset data structure
+ *
+ * This module tests the bitmapset implementation in PostgreSQL,
+ * covering all public API functions, edge cases, and memory usage.
+ *
+ * src/test/modules/test_bitmapset/test_bitmapset.c
+ */
+
+#include "postgres.h"
+
+#include <stddef.h>
+#include "catalog/pg_type.h"
+#include "common/pg_prng.h"
+#include "utils/array.h"
+#include "fmgr.h"
+#include "nodes/bitmapset.h"
+#include "nodes/nodes.h"
+#include "nodes/pg_list.h"
+#include "utils/builtins.h"
+#include "utils/timestamp.h"
+#include "varatt.h"
+
+PG_MODULE_MAGIC;
+
+/* Utility functions */
+PG_FUNCTION_INFO_V1(test_bms_from_array);
+PG_FUNCTION_INFO_V1(test_bms_to_array);
+
+/* Bitmapset API functions in order of appearance in bitmapset.c */
+PG_FUNCTION_INFO_V1(test_bms_make_singleton);
+PG_FUNCTION_INFO_V1(test_bms_add_member);
+PG_FUNCTION_INFO_V1(test_bms_del_member);
+PG_FUNCTION_INFO_V1(test_bms_is_member);
+PG_FUNCTION_INFO_V1(test_bms_num_members);
+PG_FUNCTION_INFO_V1(test_bms_copy);
+PG_FUNCTION_INFO_V1(test_bms_equal);
+PG_FUNCTION_INFO_V1(test_bms_compare);
+PG_FUNCTION_INFO_V1(test_bms_is_subset);
+PG_FUNCTION_INFO_V1(test_bms_subset_compare);
+PG_FUNCTION_INFO_V1(test_bms_union);
+PG_FUNCTION_INFO_V1(test_bms_intersect);
+PG_FUNCTION_INFO_V1(test_bms_difference);
+PG_FUNCTION_INFO_V1(test_bms_is_empty);
+PG_FUNCTION_INFO_V1(test_bms_membership);
+PG_FUNCTION_INFO_V1(test_bms_singleton_member);
+PG_FUNCTION_INFO_V1(test_bms_get_singleton_member);
+PG_FUNCTION_INFO_V1(test_bms_next_member);
+PG_FUNCTION_INFO_V1(test_bms_prev_member);
+PG_FUNCTION_INFO_V1(test_bms_hash_value);
+PG_FUNCTION_INFO_V1(test_bms_overlap);
+PG_FUNCTION_INFO_V1(test_bms_overlap_list);
+PG_FUNCTION_INFO_V1(test_bms_nonempty_difference);
+PG_FUNCTION_INFO_V1(test_bms_member_index);
+PG_FUNCTION_INFO_V1(test_bms_add_range);
+PG_FUNCTION_INFO_V1(test_bms_add_members);
+PG_FUNCTION_INFO_V1(test_bms_int_members);
+PG_FUNCTION_INFO_V1(test_bms_replace_members);
+PG_FUNCTION_INFO_V1(test_bms_join);
+PG_FUNCTION_INFO_V1(test_bitmap_hash);
+PG_FUNCTION_INFO_V1(test_bitmap_match);
+
+/* Test utility functions */
+PG_FUNCTION_INFO_V1(test_random_operations);
+
+/* Convenient macros to test results */
+#define EXPECT_TRUE(expr)	\
+	do { \
+		if (!(expr)) \
+			elog(ERROR, \
+				 "%s was unexpectedly false in file \"%s\" line %u", \
+				 #expr, __FILE__, __LINE__); \
+	} while (0)
+
+#define EXPECT_NOT_NULL(expr)	\
+	do { \
+		if ((expr) == NULL) \
+			elog(ERROR, \
+				 "%s was unexpectedly true in file \"%s\" line %u", \
+				 #expr, __FILE__, __LINE__); \
+	} while (0)
+
+/* Encode/Decode to/from TEXT and Bitmapset */
+#define BITMAPSET_TO_TEXT(bms) (text *) CStringGetTextDatum(nodeToString((bms)))
+#define TEXT_TO_BITMAPSET(str) (Bitmapset *) stringToNode(TextDatumGetCString((Datum) (str)))
+
+/*
+ * Individual test functions for each bitmapset API function
+ */
+
+Datum
+test_bms_add_member(PG_FUNCTION_ARGS)
+{
+	int			member;
+	Bitmapset  *bms = NULL;
+	text	   *result;
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_NULL();
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	member = PG_GETARG_INT32(1);
+	bms = bms_add_member(bms, member);
+	result = BITMAPSET_TO_TEXT(bms);
+
+	if (bms)
+		bms_free(bms);
+
+	if (result == NULL)
+		PG_RETURN_NULL();
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_add_members(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	/* IMPORTANT: bms_add_members modifies/frees the first argument */
+	bms1 = bms_add_members(bms1, bms2);
+
+	if (bms2)
+		bms_free(bms2);
+
+	if (bms1 == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(bms1);
+	bms_free(bms1);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_del_member(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int32		member;
+	text	   *result;
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_NULL();
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	member = PG_GETARG_INT32(1);
+	bms = bms_del_member(bms, member);
+
+	if (bms == NULL || bms_is_empty(bms))
+	{
+		if (bms)
+			bms_free(bms);
+		PG_RETURN_NULL();
+	}
+
+	result = BITMAPSET_TO_TEXT(bms);
+	bms_free(bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_is_member(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int32		member;
+	bool		result;
+
+	if (PG_ARGISNULL(1))
+		PG_RETURN_BOOL(false);
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	member = PG_GETARG_INT32(1);
+	result = bms_is_member(member, bms);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_num_members(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int			result = 0;
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	result = bms_num_members(bms);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_INT32(result);
+}
+
+Datum
+test_bms_make_singleton(PG_FUNCTION_ARGS)
+{
+	int32		member;
+	Bitmapset  *bms;
+	text	   *result;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	member = PG_GETARG_INT32(0);
+	bms = bms_make_singleton(member);
+
+	result = BITMAPSET_TO_TEXT(bms);
+	bms_free(bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_copy(PG_FUNCTION_ARGS)
+{
+	text	   *bms_data;
+	Bitmapset  *bms = NULL;
+	Bitmapset  *copy_bms;
+	text	   *result;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_NULL();
+
+	bms_data = PG_GETARG_TEXT_PP(0);
+	bms = TEXT_TO_BITMAPSET(bms_data);
+	copy_bms = bms_copy(bms);
+	result = BITMAPSET_TO_TEXT(copy_bms);
+
+	if (bms)
+		bms_free(bms);
+	if (copy_bms)
+		bms_free(copy_bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_equal(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	bool		result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result = bms_equal(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_union(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	Bitmapset  *result_bms;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result_bms = bms_union(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	if (result_bms == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(result_bms);
+	bms_free(result_bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_membership(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	BMS_Membership result;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_INT32(BMS_EMPTY_SET);
+
+	bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+	result = bms_membership(bms);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_INT32((int32) result);
+}
+
+Datum
+test_bms_next_member(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int32		prevmember;
+	int			result;
+
+	if (PG_ARGISNULL(0) || PG_ARGISNULL(1))
+		PG_RETURN_INT32(-2);
+
+	bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+	prevmember = PG_GETARG_INT32(1);
+	result = bms_next_member(bms, prevmember);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_INT32(result);
+}
+
+Datum
+test_bms_intersect(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	Bitmapset  *result_bms;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result_bms = bms_intersect(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	if (result_bms == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(result_bms);
+	bms_free(result_bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_difference(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	Bitmapset  *result_bms;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result_bms = bms_difference(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	if (result_bms == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(result_bms);
+	bms_free(result_bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_compare(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	int			result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result = bms_compare(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_INT32(result);
+}
+
+Datum
+test_bms_is_empty(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	bool		result;
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	result = bms_is_empty(bms);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_is_subset(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	bool		result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result = bms_is_subset(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_subset_compare(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	BMS_Comparison result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result = bms_subset_compare(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_INT32((int32) result);
+}
+
+Datum
+test_bms_singleton_member(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int			result;
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	result = bms_singleton_member(bms);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_INT32(result);
+}
+
+Datum
+test_bms_get_singleton_member(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int32		default_member = PG_GETARG_INT32(1);
+	int			member;
+	bool		success;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_INT32(default_member);
+
+	bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	/*
+	 * bms_get_singleton_member returns bool and stores result in member
+	 * pointer
+	 */
+	success = bms_get_singleton_member(bms, &member);
+	bms_free(bms);
+
+	if (success)
+		PG_RETURN_INT32(member);
+	else
+		PG_RETURN_INT32(default_member);
+}
+
+Datum
+test_bms_prev_member(PG_FUNCTION_ARGS)
+{
+	text	   *bms_data;
+	Bitmapset  *bms = NULL;
+	int32		prevmember;
+	int			result;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_INT32(-2);
+
+	bms_data = PG_GETARG_TEXT_PP(0);
+	prevmember = PG_GETARG_INT32(1);
+
+	if (VARSIZE_ANY_EXHDR(bms_data) == 0)
+		PG_RETURN_INT32(-2);
+
+	bms = TEXT_TO_BITMAPSET(bms_data);
+	result = bms_prev_member(bms, prevmember);
+	bms_free(bms);
+
+	PG_RETURN_INT32(result);
+}
+
+Datum
+test_bms_overlap(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	bool		result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result = bms_overlap(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_overlap_list(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	ArrayType  *array;
+	List	   *int_list = NIL;
+	bool		result;
+	Datum	   *elem_datums;
+	bool	   *elem_nulls;
+	int			elem_count;
+	int			i;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_BOOL(false);
+
+	bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (PG_ARGISNULL(1))
+	{
+		if (bms)
+			bms_free(bms);
+		PG_RETURN_BOOL(false);
+	}
+
+	array = PG_GETARG_ARRAYTYPE_P(1);
+
+	if (ARR_ELEMTYPE(array) != INT4OID)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATATYPE_MISMATCH),
+				 errmsg("integer array expected")));
+
+	deconstruct_array(array,
+					  INT4OID, sizeof(int32), true, 'i',
+					  &elem_datums, &elem_nulls, &elem_count);
+
+	for (i = 0; i < elem_count; i++)
+	{
+		if (!elem_nulls[i])
+		{
+			int32		member = DatumGetInt32(elem_datums[i]);
+
+			int_list = lappend_int(int_list, member);
+		}
+	}
+
+	result = bms_overlap_list(bms, int_list);
+
+	if (bms)
+		bms_free(bms);
+
+	list_free(int_list);
+
+	pfree(elem_datums);
+	pfree(elem_nulls);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_nonempty_difference(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	bool		result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	result = bms_nonempty_difference(bms1, bms2);
+
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_BOOL(result);
+}
+
+Datum
+test_bms_member_index(PG_FUNCTION_ARGS)
+{
+	text	   *bms_data;
+	Bitmapset  *bms = NULL;
+	int32		member;
+	int			result;
+
+	if (PG_ARGISNULL(0))
+		PG_RETURN_INT32(-1);
+
+	bms_data = PG_GETARG_TEXT_PP(0);
+	member = PG_GETARG_INT32(1);
+
+	if (VARSIZE_ANY_EXHDR(bms_data) == 0)
+		PG_RETURN_INT32(-1);
+
+	bms = TEXT_TO_BITMAPSET(bms_data);
+
+	result = bms_member_index(bms, member);
+	bms_free(bms);
+
+	PG_RETURN_INT32(result);
+}
+
+Datum
+test_bms_add_range(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	int32		lower,
+				upper;
+	text	   *result;
+
+	if (PG_ARGISNULL(1) || PG_ARGISNULL(2))
+		PG_RETURN_NULL();
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	lower = PG_GETARG_INT32(1);
+	upper = PG_GETARG_INT32(2);
+
+	/* Check for invalid range */
+	if (upper < lower)
+	{
+		if (bms)
+			bms_free(bms);
+		PG_RETURN_NULL();
+	}
+
+	bms = bms_add_range(bms, lower, upper);
+
+	result = BITMAPSET_TO_TEXT(bms);
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_int_members(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	bms1 = bms_int_members(bms1, bms2);
+
+	if (bms2)
+		bms_free(bms2);
+
+	if (bms1 == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(bms1);
+
+	if (bms1)
+		bms_free(bms1);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_replace_members(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	Bitmapset  *result_bms;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	/* IMPORTANT: bms_replace_members modifies/frees the first argument */
+	result_bms = bms_replace_members(bms1, bms2);
+	/* bms1 is now invalid, don't free it */
+
+	if (bms2)
+		bms_free(bms2);
+
+	if (result_bms == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(result_bms);
+	bms_free(result_bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_join(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	Bitmapset  *result_bms;
+	text	   *result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	/* IMPORTANT: bms_join modifies/frees the first argument */
+	result_bms = bms_join(bms1, bms2);
+	/* bms1 is now invalid! Don't free it */
+
+	if (bms2)
+		bms_free(bms2);
+
+	if (result_bms == NULL)
+		PG_RETURN_NULL();
+
+	result = BITMAPSET_TO_TEXT(result_bms);
+	bms_free(result_bms);
+
+	PG_RETURN_TEXT_P(result);
+}
+
+Datum
+test_bms_hash_value(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	uint32		hash_result;
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	hash_result = bms_hash_value(bms);
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_INT32(hash_result);
+}
+
+Datum
+test_bitmap_hash(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms = NULL;
+	Bitmapset  *bms_ptr;
+	uint32		hash_result;
+
+	if (!PG_ARGISNULL(0))
+		bms = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	bms_ptr = bms;
+
+	/* Call bitmap_hash */
+	hash_result = bitmap_hash(&bms_ptr, sizeof(Bitmapset *));
+
+	/* Clean up */
+	if (!PG_ARGISNULL(0) && bms_ptr)
+		bms_free(bms_ptr);
+
+	PG_RETURN_INT32(hash_result);
+}
+
+Datum
+test_bitmap_match(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL,
+			   *bms2 = NULL;
+	Bitmapset  *bms_ptr1,
+			   *bms_ptr2;
+	int			match_result;
+
+	if (!PG_ARGISNULL(0))
+		bms1 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(0));
+
+	if (!PG_ARGISNULL(1))
+		bms2 = TEXT_TO_BITMAPSET(PG_GETARG_TEXT_PP(1));
+
+	/* Set up pointers to the Bitmapsets */
+	bms_ptr1 = bms1;
+	bms_ptr2 = bms2;
+
+	/* Call bitmap_match with addresses of the Bitmapset pointers */
+	match_result = bitmap_match(&bms_ptr1, &bms_ptr2, sizeof(Bitmapset *));
+
+	/* Clean up */
+	if (bms1)
+		bms_free(bms1);
+	if (bms2)
+		bms_free(bms2);
+
+	PG_RETURN_INT32(match_result);
+}
+
+Datum
+test_random_operations(PG_FUNCTION_ARGS)
+{
+	Bitmapset  *bms1 = NULL;
+	Bitmapset  *bms2 = NULL;
+	Bitmapset  *bms = NULL;
+	Bitmapset  *result = NULL;
+	pg_prng_state state;
+	uint64		seed = GetCurrentTimestamp();
+	int			num_ops = 5000;
+	int			total_ops = 0;
+	int			max_range = 2000;
+	int			min_value = 0;
+	int			member;
+	int		   *members;
+	int			num_members = 0;
+
+	if (!PG_ARGISNULL(0) && PG_GETARG_INT32(0) > 0)
+		seed = PG_GETARG_INT32(0);
+
+	if (!PG_ARGISNULL(1))
+		num_ops = PG_GETARG_INT32(1);
+
+	if (!PG_ARGISNULL(2))
+		max_range = PG_GETARG_INT32(2);
+
+	if (!PG_ARGISNULL(3))
+		min_value = PG_GETARG_INT32(3);
+
+	pg_prng_seed(&state, seed);
+	members = palloc(sizeof(int) * num_ops);
+
+	/* Phase 1: Random insertions */
+	for (int i = 0; i < num_ops / 2; i++)
+	{
+		member = pg_prng_uint32(&state) % max_range + min_value;
+
+		if (!bms_is_member(member, bms1))
+		{
+			members[num_members++] = member;
+			bms1 = bms_add_member(bms1, member);
+		}
+	}
+
+	/* Phase 2: Random set operations */
+	for (int i = 0; i < num_ops / 4; i++)
+	{
+		member = pg_prng_uint32(&state) % max_range + min_value;
+
+		bms2 = bms_add_member(bms2, member);
+	}
+
+	/* Test union */
+	result = bms_union(bms1, bms2);
+	EXPECT_NOT_NULL(result);
+
+	/* Verify union contains all members from first set */
+	for (int i = 0; i < num_members; i++)
+	{
+		if (!bms_is_member(members[i], result))
+			elog(ERROR, "union missing member %d", members[i]);
+	}
+	bms_free(result);
+
+	/* Test intersection */
+	result = bms_intersect(bms1, bms2);
+	if (result != NULL)
+	{
+		member = -1;
+
+		while ((member = bms_next_member(result, member)) >= 0)
+		{
+			if (!bms_is_member(member, bms1) || !bms_is_member(member, bms2))
+				elog(ERROR, "intersection contains invalid member %d", member);
+		}
+		bms_free(result);
+	}
+
+	/* Phase 3: Test range operations */
+	result = NULL;
+	for (int i = 0; i < 10; i++)
+	{
+		int			lower = pg_prng_uint32(&state) % 100;
+		int			upper = lower + (pg_prng_uint32(&state) % 20);
+
+		result = bms_add_range(result, lower, upper);
+	}
+	if (result != NULL)
+	{
+		EXPECT_TRUE(bms_num_members(result) > 0);
+		bms_free(result);
+	}
+
+	pfree(members);
+	bms_free(bms1);
+	bms_free(bms2);
+
+	for (int i = 0; i < num_ops; i++)
+	{
+		member = pg_prng_uint32(&state) % max_range + min_value;
+		switch (pg_prng_uint32(&state) % 3)
+		{
+			case 0:				/* add */
+				bms = bms_add_member(bms, member);
+				break;
+			case 1:				/* delete */
+				if (bms != NULL)
+				{
+					bms = bms_del_member(bms, member);
+				}
+				break;
+			case 2:				/* test membership */
+				if (bms != NULL)
+				{
+					bms_is_member(member, bms);
+				}
+				break;
+		}
+		total_ops++;
+	}
+
+	if (bms)
+		bms_free(bms);
+
+	PG_RETURN_INT32(total_ops);
+}
diff --git a/src/test/modules/test_bitmapset/test_bitmapset.control b/src/test/modules/test_bitmapset/test_bitmapset.control
new file mode 100644
index 00000000000..8d02ec8bf0a
--- /dev/null
+++ b/src/test/modules/test_bitmapset/test_bitmapset.control
@@ -0,0 +1,4 @@
+comment = 'Test code for Bitmapset'
+default_version = '1.0'
+module_pathname = '$libdir/test_bitmapset'
+relocatable = true