@jairodri/huckleberry-cli 1.0.1 → 1.1.0

package/skills/claw-compactor/tests/test_real_workspace.py

@@ -0,0 +1,161 @@
+"""Performance tests against real workspace data — verifies actual savings."""
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+
+from compress_memory import rule_compress
+from lib.tokens import estimate_tokens
+from lib.dictionary import build_codebook, compress_text, decompress_text
+from lib.tokenizer_optimizer import optimize_tokens
+from lib.rle import compress as rle_compress
+
+WORKSPACE = Path("/home/user/workspace")
+
+
+def _skip_if_no_workspace():
+    if not WORKSPACE.is_dir():
+        pytest.skip("Real workspace not available")
+
+
+def _read_workspace_texts():
+    _skip_if_no_workspace()
+    texts = {}
+    for name in ["MEMORY.md", "TOOLS.md", "AGENTS.md", "SOUL.md", "USER.md"]:
+        p = WORKSPACE / name
+        if p.exists():
+            texts[name] = p.read_text()
+    mem = WORKSPACE / "memory"
+    if mem.is_dir():
+        for f in sorted(mem.rglob("*.md"))[:20]:
+            texts[f.name] = f.read_text()
+    return texts
+
+
+class TestRealWorkspacePerformance:
+    """Tests against real workspace data to verify savings claims."""
+
+    def test_rule_compress_saves_tokens(self):
+        texts = _read_workspace_texts()
+        if not texts:
+            pytest.skip("No workspace files")
+        total_before = sum(estimate_tokens(t) for t in texts.values())
+        total_after = sum(estimate_tokens(rule_compress(t)) for t in texts.values())
+        saved = total_before - total_after
+        pct = (saved / total_before * 100) if total_before > 0 else 0
+        assert saved >= 0, "Rule compression should not increase tokens"
+        print(f"\nRule compress: {total_before:,} → {total_after:,} (saved {saved:,}, {pct:.1f}%)")
+
+    def test_dictionary_saves_tokens(self):
+        texts = _read_workspace_texts()
+        if not texts:
+            pytest.skip("No workspace files")
+        combined = "\n".join(texts.values())
+        codebook = build_codebook([combined])
+        compressed = compress_text(combined, codebook)
+        before = estimate_tokens(combined)
+        after = estimate_tokens(compressed)
+        saved = before - after
+        assert saved >= 0, "Dictionary compression should not increase tokens"
+        # Verify roundtrip
+        assert decompress_text(compressed, codebook) == combined
+        print(f"\nDict compress: {before:,} → {after:,} (saved {saved:,})")
+
+    def test_tokenizer_optimize_saves_tokens(self):
+        texts = _read_workspace_texts()
+        if not texts:
+            pytest.skip("No workspace files")
+        total_before = sum(estimate_tokens(t) for t in texts.values())
+        total_after = sum(estimate_tokens(optimize_tokens(t)) for t in texts.values())
+        saved = total_before - total_after
+        assert saved >= 0, "Tokenizer optimize should not increase tokens"
+        print(f"\nTokenizer optimize: {total_before:,} → {total_after:,} (saved {saved:,})")
+
+    def test_combined_pipeline_savings(self):
+        """Full pipeline on real data."""
+        texts = _read_workspace_texts()
+        if not texts:
+            pytest.skip("No workspace files")
+
+        combined = "\n".join(texts.values())
+        initial = estimate_tokens(combined)
+
+        # Step 1: Rule compress
+        rule_texts = {k: rule_compress(v) for k, v in texts.items()}
+        rule_combined = "\n".join(rule_texts.values())
+        after_rule = estimate_tokens(rule_combined)
+
+        # Step 2: Dict compress
+        codebook = build_codebook([rule_combined])
+        dict_combined = compress_text(rule_combined, codebook)
+        after_dict = estimate_tokens(dict_combined)
+
+        # Step 3: Tokenizer optimize
+        opt_combined = optimize_tokens(dict_combined)
+        after_opt = estimate_tokens(opt_combined)
+
+        total_saved = initial - after_opt
+        pct = (total_saved / initial * 100) if initial > 0 else 0
+
+        print(f"\n=== Combined Pipeline ===")
+        print(f"  Initial:    {initial:,} tokens")
+        print(f"  After rule: {after_rule:,} ({initial - after_rule:,} saved)")
+        print(f"  After dict: {after_dict:,} ({after_rule - after_dict:,} saved)")
+        print(f"  After opt:  {after_opt:,} ({after_dict - after_opt:,} saved)")
+        print(f"  TOTAL: {total_saved:,} tokens saved ({pct:.1f}%)")
+
+        assert total_saved >= 0
+
+    def test_per_file_breakdown(self):
+        texts = _read_workspace_texts()
+        if not texts:
+            pytest.skip("No workspace files")
+
+        print(f"\n{'File':<25} | {'Before':>7} | {'After':>7} | {'Saved':>6} | {'%':>5}")
+        print(f"{'-'*25}-+-{'-'*7}-+-{'-'*7}-+-{'-'*6}-+-{'-'*5}")
+
+        for name, text in sorted(texts.items()):
+            before = estimate_tokens(text)
+            compressed = rule_compress(text)
+            after = estimate_tokens(compressed)
+            saved = before - after
+            pct = (saved / before * 100) if before > 0 else 0
+            print(f"{name:<25} | {before:>7,} | {after:>7,} | {saved:>6,} | {pct:>4.1f}%")
+            assert saved >= 0, f"{name}: compression increased tokens!"
+
+
+class TestSessionTranscriptStats:
+    """Verify session transcript compression claims."""
+
+    def test_transcript_exists(self):
+        _skip_if_no_workspace()
+        sessions_dir = Path.home() / ".openclaw" / "agents" / "main" / "sessions"
+        if not sessions_dir.is_dir():
+            pytest.skip("No sessions directory")
+        files = list(sessions_dir.glob("*.jsonl"))
+        print(f"\nFound {len(files)} session transcripts")
+        assert len(files) >= 0  # Just report
+
+    def test_sample_transcript_compression(self):
+        _skip_if_no_workspace()
+        sessions_dir = Path.home() / ".openclaw" / "agents" / "main" / "sessions"
+        if not sessions_dir.is_dir():
+            pytest.skip("No sessions directory")
+        files = sorted(sessions_dir.glob("*.jsonl"))
+        if not files:
+            pytest.skip("No session files")
+
+        from observation_compressor import compress_session, format_observations_md
+
+        # Take first file only
+        f = files[0]
+        original_tokens = estimate_tokens(f.read_text())
+        result = compress_session(f)
+        obs = result.get("observations", [])
+        compressed_text = format_observations_md(obs)
+        compressed_tokens = estimate_tokens(compressed_text) if compressed_text.strip() else 0
+
+        if original_tokens > 0:
+            ratio = (1 - compressed_tokens / original_tokens) * 100
+            print(f"\nSample transcript: {original_tokens:,} → {compressed_tokens:,} ({ratio:.1f}% compression)")

package/skills/claw-compactor/tests/test_rle.py

@@ -0,0 +1,114 @@
+"""Tests for RLE (Run-Length Encoding) structured data compression."""
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from lib.rle import (
+    compress_paths, decompress_paths,
+    compress_ip_families, decompress_ip_families,
+    compress_enumerations, compress,
+    decompress,
+)
+
+
+WS_PATH = "/home/user/workspace"
+
+
+class TestCompressPaths:
+    def test_basic(self):
+        text = f"File at {WS_PATH}/memory/test.md"
+        result = compress_paths(text, [WS_PATH])
+        assert "$WS/memory/test.md" in result
+        assert WS_PATH not in result
+
+    def test_multiple_occurrences(self):
+        text = f"{WS_PATH}/a.md and {WS_PATH}/b.md"
+        result = compress_paths(text, [WS_PATH])
+        assert result.count("$WS") == 2
+
+    def test_no_match(self):
+        text = "No paths here"
+        assert compress_paths(text, [WS_PATH]) == text
+
+    def test_roundtrip(self):
+        text = f"Path: {WS_PATH}/skills/claw-compactor"
+        compressed = compress_paths(text, [WS_PATH])
+        decompressed = decompress_paths(compressed, WS_PATH)
+        assert decompressed == text
+
+
+class TestCompressIPFamilies:
+    def test_basic(self):
+        text = "Server at 10.0.1.1 and node at 10.0.1.2"
+        result, prefix_map = compress_ip_families(text)
+        assert len(prefix_map) > 0
+        # Should be shorter
+        assert len(result) < len(text)
+
+    def test_roundtrip(self):
+        text = "IPs: 10.0.1.1, 10.0.1.2, 10.0.1.3"
+        compressed, prefix_map = compress_ip_families(text)
+        decompressed = decompress_ip_families(compressed, prefix_map)
+        # All original IPs should be present
+        assert "10.0.1.1" in decompressed
+        assert "10.0.1.2" in decompressed
+        assert "10.0.1.3" in decompressed
+
+    def test_different_subnets(self):
+        text = "10.0.0.1 and 10.0.0.2 and 192.168.1.1"
+        result, prefix_map = compress_ip_families(text)
+        # 10.0.0.x family should be compressed
+        assert "$IP" in result or len(prefix_map) > 0
+
+    def test_single_ip_no_compress(self):
+        text = "Only one IP: 10.0.0.1"
+        result, prefix_map = compress_ip_families(text)
+        assert result == text
+        assert len(prefix_map) == 0
+
+
+class TestCompressEnumerations:
+    def test_ticker_list(self):
+        text = "Trading pairs: BTC, ETH, SOL, BNB, DOGE"
+        result = compress_enumerations(text)
+        assert "[BTC,ETH,SOL,BNB,DOGE]" in result
+
+    def test_short_list_no_change(self):
+        text = "BTC, ETH, SOL"
+        result = compress_enumerations(text)
+        assert result == text  # Only 3 items, no change
+
+    def test_mixed_case_no_change(self):
+        text = "apple, banana, cherry, date"
+        result = compress_enumerations(text)
+        assert result == text  # Not all-caps codes
+
+
+class TestCompress:
+    def test_combined(self):
+        text = (
+            f"Connected to {WS_PATH}/config\n"
+            "IPs: 10.0.1.1, 10.0.1.2\n"
+            "Tokens: BTC, ETH, SOL, BNB, DOGE\n"
+        )
+        result = compress(text, [WS_PATH])
+        assert "$WS" in result
+        assert len(result) < len(text)
+
+    def test_empty(self):
+        assert compress("") == ""
+
+    def test_unicode(self):
+        text = f"中文路径 {WS_PATH}/中文文件.md"
+        result = compress(text, [WS_PATH])
+        assert "中文" in result
+        assert "$WS" in result
+
+    def test_decompress_paths(self):
+        text = f"Path: {WS_PATH}/test"
+        compressed = compress(text, [WS_PATH])
+        decompressed = decompress(compressed, WS_PATH)
+        assert WS_PATH in decompressed

package/skills/claw-compactor/tests/test_rle_comprehensive.py

@@ -0,0 +1,151 @@
+"""Comprehensive tests for lib/rle.py."""
+import sys
+import pytest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from lib.rle import (
+    compress_paths, decompress_paths,
+    compress_ip_families, decompress_ip_families,
+    compress_enumerations, compress_repeated_headers,
+    compress, decompress,
+)
+
+
+class TestCompressPaths:
+    def test_basic(self):
+        ws = "/Users/duke/workspace"
+        text = f"File at {ws}/memory/test.md"
+        result = compress_paths(text, [ws])
+        assert "$WS" in result or ws not in result or result == text
+
+    def test_multiple_paths(self):
+        ws = "/Users/duke/workspace"
+        text = f"{ws}/a.md and {ws}/b.md and {ws}/c.md"
+        result = compress_paths(text, [ws])
+        assert isinstance(result, str)
+
+    def test_no_match(self):
+        text = "no paths here"
+        result = compress_paths(text, ["/Users/duke/workspace"])
+        assert result == text
+
+    def test_empty(self):
+        result = compress_paths("", ["/Users/duke"])
+        assert result == ""
+
+    def test_none_workspace(self):
+        result = compress_paths("some text", None)
+        assert result == "some text"
+
+    def test_empty_workspace_list(self):
+        result = compress_paths("some text", [])
+        assert result == "some text"
+
+
+class TestCompressIPFamilies:
+    def test_basic_family(self):
+        text = "192.168.1.100 and 192.168.1.200 and 192.168.1.50"
+        result, prefix_map = compress_ip_families(text)
+        assert isinstance(result, str)
+        assert isinstance(prefix_map, dict)
+
+    def test_no_ips(self):
+        text = "no ips here"
+        result, prefix_map = compress_ip_families(text)
+        assert result == text
+
+    def test_single_ip(self):
+        text = "host: 10.0.0.1"
+        result, prefix_map = compress_ip_families(text)
+        assert isinstance(result, str)
+
+    def test_different_subnets(self):
+        text = "10.0.0.1 and 192.168.1.1 and 172.16.0.1"
+        result, prefix_map = compress_ip_families(text)
+        assert isinstance(result, str)
+
+    def test_empty(self):
+        result, _ = compress_ip_families("")
+        assert result == ""
+
+    def test_min_occurrences(self):
+        text = "10.0.0.1 once"
+        result, _ = compress_ip_families(text, min_occurrences=5)
+        assert result == text
+
+
+class TestCompressEnumerations:
+    def test_basic(self):
+        text = "worker-1, worker-2, worker-3, worker-4, worker-5"
+        result = compress_enumerations(text)
+        assert isinstance(result, str)
+
+    def test_no_enumerations(self):
+        text = "no enumerations here"
+        assert compress_enumerations(text) == text
+
+    def test_empty(self):
+        assert compress_enumerations("") == ""
+
+    def test_numbered_items(self):
+        text = "node-1 node-2 node-3 node-4"
+        result = compress_enumerations(text)
+        assert isinstance(result, str)
+
+
+class TestCompressRepeatedHeaders:
+    def test_repeated(self):
+        text = "## Section\nfoo\n## Section\nbar"
+        result = compress_repeated_headers(text)
+        assert isinstance(result, str)
+
+    def test_no_repeats(self):
+        text = "## A\nfoo\n## B\nbar"
+        result = compress_repeated_headers(text)
+        assert "A" in result and "B" in result
+
+    def test_empty(self):
+        assert compress_repeated_headers("") == ""
+
+
+class TestCompress:
+    """Test the main compress() function."""
+
+    def test_basic(self):
+        text = "Some text with /Users/duke/workspace/file.md"
+        result = compress(text, ["/Users/duke/workspace"])
+        assert isinstance(result, str)
+
+    def test_empty(self):
+        assert compress("") == ""
+
+    def test_no_compression_needed(self):
+        text = "plain text"
+        result = compress(text)
+        assert result == text
+
+    def test_combined_features(self):
+        text = (
+            "192.168.1.100 and 192.168.1.200\n"
+            "worker-1, worker-2, worker-3\n"
+            "## Header\nfoo\n## Header\nbar"
+        )
+        result = compress(text)
+        assert isinstance(result, str)
+
+
+class TestDecompress:
+    def test_basic_roundtrip(self):
+        ws = "/Users/duke/workspace"
+        text = f"{ws}/test.md"
+        compressed = compress(text, [ws])
+        decompressed = decompress(compressed, ws)
+        assert text in decompressed or decompressed == text
+
+    def test_empty(self):
+        assert decompress("", "/Users/duke") == ""
+
+    def test_no_markers(self):
+        text = "nothing to decompress"
+        assert decompress(text, "/Users/duke") == text

package/skills/claw-compactor/tests/test_roundtrip.py

@@ -0,0 +1,253 @@
+"""Roundtrip tests — the most important invariant.
+
+compress → decompress MUST equal original for all lossless techniques.
+Tests cover: ASCII, Chinese, mixed, edge cases, $-containing text.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
+from lib.dictionary import (
+    build_codebook, compress_text, decompress_text,
+    save_codebook, load_codebook,
+)
+from lib.rle import (
+    compress_paths, decompress_paths,
+    compress_ip_families, decompress_ip_families,
+)
+
+
+# --- Dictionary Roundtrip ---
+
+class TestDictionaryRoundtripASCII:
+    """Pure ASCII text roundtrips."""
+
+    @pytest.fixture
+    def codebook(self):
+        return {
+            "$GW": "10.0.1.1",
+            "$JP": "10.0.1.2",
+            "$TK": "my-secret-token-2024",
+            "$WS": "/home/user/workspace",
+        }
+
+    def test_simple(self, codebook):
+        text = "Gateway at 10.0.1.1 running"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_multiple_replacements(self, codebook):
+        text = "Connect to 10.0.1.1 via 10.0.1.2 using my-secret-token-2024"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_no_matches(self, codebook):
+        text = "Nothing matches here at all"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_all_replaced(self, codebook):
+        text = "10.0.1.1"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_multiline(self, codebook):
+        text = "Line 1: 10.0.1.1\nLine 2: 10.0.1.2\nLine 3: done"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_adjacent_matches(self, codebook):
+        text = "10.0.1.110.0.1.2"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_repeated(self, codebook):
+        text = "10.0.1.1 and 10.0.1.1 and 10.0.1.1"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+
+class TestDictionaryRoundtripChinese:
+    """Chinese text roundtrips."""
+
+    @pytest.fixture
+    def codebook(self):
+        return {
+            "$CN": "日本节点",
+            "$GW": "网关服务器",
+            "$WS": "工作空间目录",
+        }
+
+    def test_pure_chinese(self, codebook):
+        text = "连接到日本节点的网关服务器，在工作空间目录下操作"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_no_chinese_matches(self, codebook):
+        text = "纯中文但没有匹配的词语"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+
+class TestDictionaryRoundtripMixed:
+    """Mixed ASCII + Chinese text roundtrips."""
+
+    @pytest.fixture
+    def codebook(self):
+        return {
+            "$GW": "10.0.1.1",
+            "$JP": "日本节点",
+            "$TK": "my-secret-token-2024",
+        }
+
+    def test_mixed(self, codebook):
+        text = "连接到10.0.1.1的日本节点，使用my-secret-token-2024认证"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+    def test_mixed_multiline(self, codebook):
+        text = "# 配置\n- 网关: 10.0.1.1\n- 节点: 日本节点\n- Token: my-secret-token-2024\n"
+        assert decompress_text(compress_text(text, codebook), codebook) == text
+
+
+class TestDictionaryRoundtripDollarSign:
+    """Text containing $ that could conflict with code format."""
+
+    @pytest.fixture
+    def codebook(self):
+        return {
+            "$GW": "gateway",
+            "$JP": "japan",
+        }
+
+    def test_dollar_in_text(self, codebook):
+        """Text with $ should not be corrupted."""
+        text = "Price is $100 and gateway is main"
+        compressed = compress_text(text, codebook)
+        decompressed = decompress_text(compressed, codebook)
+        assert decompressed == text
+
+    def test_dollar_code_like_in_text(self, codebook):
+        """Text that looks like a code ($XX) but isn't in codebook."""
+        text = "Variable $AB is not a code, gateway runs"
+        compressed = compress_text(text, codebook)
+        decompressed = decompress_text(compressed, codebook)
+        assert decompressed == text
+
+    def test_existing_code_in_text(self, codebook):
+        """If text already contains $GW literally (not from codebook),
+        roundtrip may not be perfect — this is a known limitation.
+        The codebook should avoid phrases that look like codes."""
+        text = "The code $GW was already in the text"
+        compressed = compress_text(text, codebook)
+        # After compress: $GW is still $GW (text didn't contain "gateway" to replace)
+        # After decompress: $GW → "gateway"... this corrupts!
+        # This is expected — the codebook builder avoids this case
+        # by not creating codes that conflict with existing text
+
+
+class TestDictionaryRoundtripEmpty:
+    """Empty and edge case roundtrips."""
+
+    def test_empty_text(self):
+        cb = {"$AA": "test"}
+        assert decompress_text(compress_text("", cb), cb) == ""
+
+    def test_empty_codebook(self):
+        assert decompress_text(compress_text("hello", {}), {}) == "hello"
+
+    def test_both_empty(self):
+        assert decompress_text(compress_text("", {}), {}) == ""
+
+    def test_only_whitespace(self):
+        cb = {"$AA": "test"}
+        text = "   \n\n\t  "
+        assert decompress_text(compress_text(text, cb), cb) == text
+
+
+class TestDictionaryRoundtripBuiltCodebook:
+    """Roundtrip using auto-built codebooks from real-ish data."""
+
+    def test_workspace_like_data(self):
+        texts = [
+            "# Config\n- Gateway: 10.0.1.1\n- Node: remote-node 10.0.1.2\n"
+            "- Path: /home/user/workspace\n- Token: my-token-2024\n",
+        ] * 5  # Repeat to ensure frequency
+        cb = build_codebook(texts, min_freq=3)
+        for text in texts:
+            assert decompress_text(compress_text(text, cb), cb) == text
+
+    def test_unicode_heavy_data(self):
+        texts = [
+            "# 服务器配置\n- 网关服务器地址: 10.0.1.1\n- 日本节点地址: 10.0.2.1\n",
+        ] * 5
+        cb = build_codebook(texts, min_freq=3)
+        for text in texts:
+            assert decompress_text(compress_text(text, cb), cb) == text
+
+    def test_save_load_preserves_roundtrip(self, tmp_path):
+        """Codebook saved to disk and reloaded still roundtrips."""
+        texts = [
+            "server 192.168.1.100 with token super-long-token-value-here\n" * 3,
+        ] * 3
+        cb = build_codebook(texts, min_freq=2)
+        if not cb:
+            pytest.skip("No codebook built")
+
+        path = tmp_path / "cb.json"
+        save_codebook(cb, path)
+        loaded_cb = load_codebook(path)
+
+        combined = '\n'.join(texts)
+        compressed = compress_text(combined, loaded_cb)
+        decompressed = decompress_text(compressed, loaded_cb)
+        assert decompressed == combined
+
+
+# --- RLE Roundtrip ---
+
+class TestRLEPathRoundtrip:
+    """$WS path roundtrip."""
+
+    WS = "/home/user/workspace"
+
+    def test_basic(self):
+        text = f"File: {self.WS}/memory/test.md"
+        compressed = compress_paths(text, [self.WS])
+        decompressed = decompress_paths(compressed, self.WS)
+        assert decompressed == text
+
+    def test_multiple(self):
+        text = f"{self.WS}/a.md and {self.WS}/b.md"
+        compressed = compress_paths(text, [self.WS])
+        decompressed = decompress_paths(compressed, self.WS)
+        assert decompressed == text
+
+    def test_no_match(self):
+        text = "no paths here"
+        compressed = compress_paths(text, [self.WS])
+        decompressed = decompress_paths(compressed, self.WS)
+        assert decompressed == text
+
+    def test_empty(self):
+        compressed = compress_paths("", [self.WS])
+        decompressed = decompress_paths(compressed, self.WS)
+        assert decompressed == ""
+
+
+class TestRLEIPRoundtrip:
+    """IP family compression roundtrip."""
+
+    def test_basic(self):
+        text = "IPs: 10.0.1.1, 10.0.1.2, 10.0.1.3"
+        compressed, prefix_map = compress_ip_families(text)
+        decompressed = decompress_ip_families(compressed, prefix_map)
+        assert "10.0.1.1" in decompressed
+        assert "10.0.1.2" in decompressed
+        assert "10.0.1.3" in decompressed
+
+    def test_no_ips(self):
+        text = "no IPs"
+        compressed, prefix_map = compress_ip_families(text)
+        decompressed = decompress_ip_families(compressed, prefix_map)
+        assert decompressed == text
+
+    def test_single_ip(self):
+        text = "Only 10.0.0.1 here"
+        compressed, prefix_map = compress_ip_families(text)
+        decompressed = decompress_ip_families(compressed, prefix_map)
+        assert decompressed == text