Hegel

Hegel

Hegel is a universal property-based testing engine and family of libraries, inspired by Hypothesis, developed in part by Hypothesis developers as part of their work at Antithesis.

First time here? We recommend starting with the Getting started guide, or reading through the example Hegel code below.

Rust

use hegel::generators as gs;
use hegel::TestCase;

#[hegel::test]
fn test_respects_lru_capacity(tc: TestCase) {
	let capacity = tc.draw(gs::integers::<usize>().min_value(0));
	let mut cache = MyLRUCache::<String, i64>::new(capacity);

	let entries = tc.draw(
	    gs::vecs(gs::tuples!(gs::text(), gs::integers::<i64>()))
	);
	for (key, value) in entries {
		cache.put(key, value);
	}

	assert!(cache.size() <= capacity);
}

Go

import (
  "math"
  "testing"
  "hegel.dev/go/hegel"
)

func TestRespectsLRUCapacity(t *testing.T) {
	hegel.Test(t, func(ht *hegel.T) {
		capacity := hegel.Draw(ht, hegel.Integers(0, math.MaxInt))
		cache := NewMyLRUCache[string, int](capacity)

		keys := hegel.Draw(ht, hegel.Lists(hegel.Text()))
		for _, key := range keys {
			value := hegel.Draw(ht, hegel.Integers(math.MinInt, math.MaxInt))
			cache.Put(key, value)
		}

		if cache.Size() > capacity {
			ht.Fatalf("cache size exceeds capacity")
		}
	})
}

C++

#include <hegel/hegel.h>
namespace gs = hegel::generators;

HEGEL_TEST(respects_lru_capacity)(hegel::TestCase& tc) {
	auto capacity = tc.draw("capacity", gs::integers<size_t>({.min_value = 0}));
	MyLRUCache<std::string, int> cache(capacity);

	auto entries = tc.draw(
	  "entries",
	  gs::vectors(gs::tuples(gs::text(), gs::integers<int>()))
	);
	for (const auto& [key, value] : entries) {
		cache.put(key, value);
	}

	if (cache.size() > capacity) {
		throw std::runtime_error("cache size exceeded capacity");
	}
}

int main() {
	respects_lru_capacity();
}

TypeScript

import { test, expect } from "vitest";
import * as hegel from "@hegeldev/hegel";
import * as gs from "@hegeldev/hegel/generators";

test("MyLRUCache respects capacity", () => {
	hegel.test((tc) => {
		const capacity = tc.draw(gs.integers({ minValue: 0 }));
		const cache = new MyLRUCache<string, number>(capacity);

		const entries = tc.draw(
		    gs.arrays(gs.tuples(gs.text(), gs.integers())),
		);
		for (const [key, value] of entries) {
		    cache.put(key, value);
		}

		expect(cache.size()).toBeLessThanOrEqual(capacity);
	});
});

Java

import static dev.hegel.Generators.*;
import static org.junit.jupiter.api.Assertions.assertTrue;

import dev.hegel.HegelTest;
import dev.hegel.TestCase;

class LRUCacheTest {
	@HegelTest
	void respectsLRUCapacity(TestCase tc) {
		int capacity = tc.draw(integers().min(0), "capacity");
		var cache = new MyLRUCache<String, Integer>(capacity);

		var entries = tc.draw(lists(tuples(text(), integers())), "entries");
		for (var entry : entries) {
			cache.put(entry.value1(), entry.value2());
		}

		assertTrue(cache.size() <= capacity);
	}
}

OCaml

open Hegel

let%hegel_test respects_lru_capacity tc =
	let capacity = draw tc (integers ~min_value:0 ()) in
	let cache = MyLRUCache.create capacity in

	let entries =
		draw tc (lists (tuples2 (text ()) (integers ())) ())
	in
	List.iter (fun (key, value) -> MyLRUCache.put cache key value) entries;

	assert (MyLRUCache.size cache <= capacity)
;;

let () =
	Alcotest.run "lru_cache"
		[ "properties", [ Alcotest.test_case "respects capacity" `Quick respects_lru_capacity ] ]
;;

Introduction

• Getting started

Explanation

• How Hegel works
• Why Hegel?