# Testing Frameworks in denoland/celld: A Complete Runtime Stack Breakdown

> Explore testing frameworks in denoland/celld. Learn how Rust's test harness, proptest, and tokio power the celld runtime stack for robust testing.

- Repository: [Deno/celld](https://github.com/denoland/celld)
- Tags: internals
- Published: 2026-09-05

---

**The denoland/celld repository uses Rust's built-in test harness with `proptest` for property-based testing and `tokio` for async test support.**

The celld project is a Rust-based serverless runtime from the Deno ecosystem. Understanding its testing stack helps contributors write effective tests and shows how modern Rust projects combine multiple frameworks for comprehensive coverage. This guide examines the exact testing frameworks used in denoland/celld, where they're configured, and how they work together.

## Core Testing Stack Overview

The celld codebase relies on three integrated components rather than a single external framework. This layered approach covers synchronous unit tests, asynchronous runtime behavior, and property-based validation.

### Rust's Native `#[test]` Harness

The foundation is Rust's built-in test framework, activated through standard `#[test]` attributes and `#[cfg(test)]` modules. No additional dependencies are required—this is the default for all Rust projects.

```rust
#[test]
fn basic_cell_write() {
    // ... test logic ...
}

```

Tests using this harness appear throughout the crate source files, typically in inline test modules guarded by `#[cfg(test)]`.

## Property-Based Testing with `proptest`

The `proptest` crate extends celld's testing capabilities with **property-based testing**, automatically generating diverse inputs to verify protocol correctness.

### Where It's Configured

In [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml) at the workspace root, `proptest` is listed as a development dependency:

```toml
[dev-dependencies]
proptest = { version = "1.0", features = ["timeout"] }

```

This entry appears at lines 105-107 of the workspace manifest.

### How It's Used

Property-based tests define invariants that must hold for any valid input, letting `proptest` generate edge cases that hand-written tests might miss:

```rust
use proptest::prelude::*;

proptest! {
    #[test]
    fn write_roundtrip(data: Vec<u8>) {
        // ... verify that a write followed by a read returns the same data ...
    }
}

```

This approach is particularly valuable for celld's core storage and networking protocols, where unexpected input combinations could expose bugs.

## Async Testing with `tokio`

Since celld is an asynchronous runtime, it needs first-class support for async tests. The `tokio` crate provides this through the `#[tokio::test]` attribute macro.

### Configuration and Dependencies

`tokio` appears in the main dependencies list at lines 128-131 of [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml), with features enabling both runtime functionality and test utilities:

```toml
[dependencies]
tokio = { version = "1", features = ["full"] }

```

### Async Test Pattern

Tests that spawn tasks, use async I/O, or interact with the runtime use this pattern:

```rust
#[tokio::test]
async fn async_cell_operation() {
    // ... async test logic ...
}

```

The `#[tokio::test]` macro automatically sets up a runtime for each test, eliminating boilerplate that would otherwise be required.

## Differential Testing Against `workerd`

Beyond the unit testing stack, celld employs **differential testing** as described in [`docs/testing.md`](https://github.com/denoland/celld/blob/main/docs/testing.md) (lines 17-24). This strategy compares celld's output against Cloudflare's `workerd` runtime to ensure compatibility.

Importantly, this verification layer builds on the same standard Rust test framework—it does not introduce additional testing dependencies. The differential approach is implemented as regular test functions that orchestrate both runtimes and assert on behavioral equivalence.

## Key Files and Their Roles

| File | Purpose |
|------|---------|
| [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml) | Workspace manifest declaring `proptest` and `tokio` dependencies |
| [`docs/testing.md`](https://github.com/denoland/celld/blob/main/docs/testing.md) | Documents testing strategy including differential tests against `workerd` |
| Crate source files with `#[cfg(test)]` modules | Contain concrete unit and async tests |

## Comparison: When to Use Each Testing Framework in celld

| Framework | Best For | Example Use Case |
|-----------|----------|----------------|
| **Native `#[test]`** | Simple, synchronous logic | Pure functions, data structure validation |
| **`tokio`** | Async runtime interaction | I/O operations, task scheduling, timers |
| **`proptest`** | Input space exploration | Protocol parsers, serialization roundtrips |

## Summary

- **Rust's built-in harness** provides the foundation for all tests in denoland/celld through `#[test]` and `#[cfg(test)]`.
- **`proptest`** enables property-based testing for robust protocol verification, configured in [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml) lines 105-107.
- **`tokio`** powers async testing via `#[tokio::test]`, declared at lines 128-131 of the workspace manifest.
- **Differential testing** against `workerd` leverages this same stack rather than adding external frameworks.
- This three-layer approach covers synchronous, asynchronous, and generative testing needs without framework sprawl.

## Frequently Asked Questions

### Does celld use a custom testing framework?

No. Celld uses standard Rust testing infrastructure with two well-known crates. The `proptest` and `tokio` dependencies enhance capabilities but do not replace Rust's native test harness.

### Where are the testing dependencies declared?

Both `proptest` and `tokio` are declared in the workspace-level [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml). `proptest` appears under `[dev-dependencies]` at lines 105-107, while `tokio` is in `[dependencies]` at lines 128-131 for runtime and async test support.

### How does celld test compatibility with other runtimes?

The project uses differential testing, comparing celld's behavior against Cloudflare's `workerd` runtime. This is documented in [`docs/testing.md`](https://github.com/denoland/celld/blob/main/docs/testing.md) and implemented as standard Rust tests that orchestrate both systems—no additional testing framework is required for this verification.