goish 0.15.0

Write Rust using Go idioms — a Go-flavored standard library for Rust
Documentation 
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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

// Port of go1.25.5 src/context/context_test.go — core semantics.
//
// Elided: the enormous propagation table (TestChildFinishesFirst,
// TestCancelRemoves, TestParentFinishesChild) that simulates hundreds of
// context trees and measures runtime stats; Cause/WithCancelCause (not
// ported yet). We cover the contract every context user actually relies
// on: Background, WithCancel, WithTimeout, WithValue, Done/Err.

#![allow(non_snake_case)]
use goish::prelude::*;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;

test!{ fn TestBackground(t) {
    let ctx = context::Background();
    if ctx.Err() != nil {
        t.Errorf(Sprintf!("Background.Err() = %s, want nil", ctx.Err()));
    }
}}

test!{ fn TestWithCancel(t) {
    let (ctx, cancel) = context::WithCancel(context::Background());
    if ctx.Err() != nil {
        t.Errorf(Sprintf!("fresh WithCancel.Err() = %s", ctx.Err()));
    }
    cancel.call();
    // Wait briefly for the propagation.
    for _ in 0..100 {
        if ctx.Err() != nil { break; }
        std::thread::sleep(Duration::from_millis(1));
    }
    let es = format!("{}", ctx.Err());
    if !strings::Contains(&es, "canceled") && !strings::Contains(&es, "Canceled") {
        t.Errorf(Sprintf!("WithCancel.Err() = %s, want 'canceled'", es));
    }
}}

test!{ fn TestWithCancelDone(t) {
    let (ctx, cancel) = context::WithCancel(context::Background());
    let done = ctx.Done();
    let flag = Arc::new(AtomicBool::new(false));
    let f = flag.clone();
    std::thread::spawn(move || {
        let _ = done.Recv();
        f.store(true, Ordering::SeqCst);
    });
    std::thread::sleep(Duration::from_millis(10));
    cancel.call();
    std::thread::sleep(Duration::from_millis(50));
    if !flag.load(Ordering::SeqCst) {
        t.Errorf(Sprintf!("Done channel did not fire after cancel"));
    }
}}

test!{ fn TestWithTimeout(t) {
    let start = time::Now();
    let (ctx, _cancel) = context::WithTimeout(context::Background(), time::Millisecond * 50i64);
    ctx.Wait();
    let elapsed = time::Since(start);
    if elapsed.Milliseconds() < 40 {
        t.Errorf(Sprintf!("WithTimeout fired too early: %d ms", elapsed.Milliseconds()));
    }
    if elapsed.Milliseconds() > 1000 {
        t.Errorf(Sprintf!("WithTimeout fired too late: %d ms", elapsed.Milliseconds()));
    }
    if ctx.Err() == nil {
        t.Errorf(Sprintf!("WithTimeout Err() = nil after deadline"));
    }
}}

test!{ fn TestWithDeadline(t) {
    let deadline = time::Now().Add(time::Millisecond * 40i64);
    let (ctx, _cancel) = context::WithDeadline(context::Background(), deadline);
    ctx.Wait();
    if ctx.Err() == nil {
        t.Errorf(Sprintf!("WithDeadline Err() = nil after deadline"));
    }
}}

test!{ fn TestWithValue(t) {
    let ctx = context::Background();
    let ctx = context::WithValue(ctx, "user", "alice".to_string());
    let got: Option<String> = ctx.Value("user");
    if got.as_deref() != Some("alice") {
        t.Errorf(Sprintf!("Value(user) = %v", got.is_some()));
    }
    // Missing key returns None.
    let missing: Option<String> = ctx.Value("missing");
    if missing.is_some() {
        t.Errorf(Sprintf!("missing key got Some"));
    }
}}

test!{ fn TestWithValueChained(t) {
    let ctx = context::Background();
    let ctx = context::WithValue(ctx, "a", 1i64);
    let ctx = context::WithValue(ctx, "b", 2i64);
    let a: Option<i64> = ctx.Value("a");
    let b: Option<i64> = ctx.Value("b");
    if a != Some(1) || b != Some(2) {
        t.Errorf(Sprintf!("Chained values: a=%v b=%v", a.is_some(), b.is_some()));
    }
}}

test!{ fn TestCancelPropagatesToChild(t) {
    let (parent, pcancel) = context::WithCancel(context::Background());
    let (child, _ccancel) = context::WithCancel(parent);
    pcancel.call();
    // Wait briefly for propagation.
    for _ in 0..100 {
        if child.Err() != nil { break; }
        std::thread::sleep(Duration::from_millis(1));
    }
    if child.Err() == nil {
        t.Errorf(Sprintf!("child did not propagate parent cancellation"));
    }
}}

test!{ fn TestMultipleCancelCalls(t) {
    // Calling cancel twice should not panic.
    let (ctx, cancel) = context::WithCancel(context::Background());
    cancel.call();
    cancel.call();
    let _ = ctx;
}}

test!{ fn TestBackgroundNeverDone(t) {
    // Background.Err() stays nil; its Done channel doesn't fire.
    let ctx = context::Background();
    if ctx.Err() != nil { t.Errorf(Sprintf!("Background Err non-nil")); }
    // Wait a bit to make sure nothing fires.
    std::thread::sleep(Duration::from_millis(20));
    if ctx.Err() != nil { t.Errorf(Sprintf!("Background Err changed")); }
}}