diff --git a/tests/mutation_source_test.cc b/tests/mutation_source_test.cc
index e31800eeb0..025c0a3adb 100644
--- a/tests/mutation_source_test.cc
+++ b/tests/mutation_source_test.cc
@@ -22,6 +22,7 @@
 #include "schema_builder.hh"
 #include "mutation_reader_assertions.hh"
 #include "mutation_source_test.hh"
+#include "counters.hh"
 
 // partitions must be sorted by decorated key
 static void require_no_token_duplicates(const std::vector<mutation>& partitions) {
@@ -190,6 +191,7 @@ static mutation_sets generate_mutation_sets() {
                 .with_column("ck_col_2", bytes_type, column_kind::clustering_key)
                 .with_column("regular_col_1", bytes_type)
                 .with_column("regular_col_2", bytes_type)
+                .with_column("regular_counter_col_1", counter_type)
                 .with_column("static_col_1", bytes_type, column_kind::static_column)
                 .with_column("static_col_2", bytes_type, column_kind::static_column);
 
@@ -378,7 +380,8 @@ public:
         auto builder = schema_builder("ks", "cf")
                 .with_column("pk", bytes_type, column_kind::partition_key)
                 .with_column("ck1", bytes_type, column_kind::clustering_key)
-                .with_column("ck2", bytes_type, column_kind::clustering_key);
+                .with_column("ck2", bytes_type, column_kind::clustering_key)
+                .with_column("c1", counter_type);
 
         // Create enough columns so that row can overflow its vector storage
         for (column_id i = 0; i < column_count; ++i) {
@@ -421,14 +424,53 @@ public:
         auto pkey = partition_key::from_single_value(*_schema, _blobs[0]);
         mutation m(pkey, _schema);
 
+        auto& counter_column = *_schema->get_column_definition(utf8_type->decompose(sstring("c1")));
+
+        std::map<counter_id, std::set<int64_t>> counter_used_clock_values;
+        std::vector<counter_id> counter_ids;
+        std::generate_n(std::back_inserter(counter_ids), 8, counter_id::generate_random);
+
+        auto random_counter_cell = [&] {
+            std::uniform_int_distribution<size_t> shard_count_dist(1, counter_ids.size());
+            std::uniform_int_distribution<int64_t> value_dist(-100, 100);
+            std::uniform_int_distribution<int64_t> clock_dist(0, 20000);
+
+            auto shard_count = shard_count_dist(_gen);
+            std::set<counter_id> shards;
+            for (auto i = 0u; i < shard_count; i++) {
+                shards.emplace(counter_ids[shard_count_dist(_gen) - 1]);
+            }
+
+            counter_cell_builder ccb;
+            for (auto&& id : shards) {
+                // Make sure we don't get shards with the same id and clock
+                // but different value.
+                int64_t clock = clock_dist(_gen);
+                while (counter_used_clock_values[id].count(clock)) {
+                    clock = clock_dist(_gen);
+                }
+                counter_used_clock_values[id].emplace(clock);
+                ccb.add_shard(counter_shard(id, value_dist(_gen), clock));
+            }
+            return ccb.build(timestamp_dist(_gen));
+        };
+
         auto set_random_cells = [&] (row& r, column_kind kind) {
             auto columns_to_set = column_count_dist(_gen);
             for (column_id i = 0; i < columns_to_set; ++i) {
+                auto cid = column_id_dist(_gen);
+                if (kind == column_kind::regular_column && cid == counter_column.id) {
+                    auto cell = bool_dist(_gen)
+                                ? random_counter_cell()
+                                : atomic_cell::make_dead(timestamp_dist(_gen), expiry_dist(_gen));
+                    r.apply(_schema->column_at(kind, cid), std::move(cell));
+                    continue;
+                }
                 // FIXME: generate expiring cells
                 auto cell = bool_dist(_gen)
                             ? atomic_cell::make_live(timestamp_dist(_gen), _blobs[value_blob_index_dist(_gen)])
                             : atomic_cell::make_dead(timestamp_dist(_gen), expiry_dist(_gen));
-                r.apply(_schema->column_at(kind, column_id_dist(_gen)), std::move(cell));
+                r.apply(_schema->column_at(kind, cid), std::move(cell));
             }
         };