euphony 0.1.1

music composition environment for programmers
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

use crate as euphony;
use euphony::output;
use std::{
    future::Future,
    io::{self, Cursor},
    sync::{Arc, Mutex},
};

#[derive(Clone, Default)]
struct List(Arc<Mutex<Cursor<Vec<u8>>>>);

impl io::Write for List {
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.0.lock().unwrap().write(buf)
    }

    fn flush(&mut self) -> io::Result<()> {
        Ok(())
    }
}

pub fn start<F>(name: &str, f: F)
where
    F: 'static + Future<Output = ()> + Send,
{
    let list = List::default();
    output::scope::set(Some(Box::new(list.clone())));

    euphony::runtime::Runtime::new(0).block_on(f);

    let mut result = core::mem::take(&mut *list.0.lock().unwrap());
    result.set_position(0);

    let mut dump = String::new();
    output::decode(&mut result, &mut dump).unwrap();

    insta::assert_display_snapshot!(name, dump);
}

use euphony::prelude::*;

#[test]
fn tempo_test() {
    start("tempo_test", async {
        for i in 0..10 {
            set_tempo(Tempo(60 + i * 10, 1));
            let s = osc::sine().with_frequency(now().as_f64());
            Beat(1, 2).delay().await;
            s.fin()
        }
    })
}

#[test]
fn rand_test() {
    start("rand_test", async {
        // make sure we have a scope in the root
        let s = osc::sine();
        for _ in 0..5 {
            s.set_frequency(rand::gen_range(0..3) as f64);
            Beat(1, 2).delay().await;
        }
        drop(s);

        // make sure spawned tasks have scopes
        async {
            let s = osc::sine();
            for _ in 0..5 {
                s.set_frequency(rand::gen_range(0..3) as f64);
                Beat(1, 2).delay().await;
            }
        }
        .spawn()
        .await;

        // make sure we can seed tasks
        async {
            let s = osc::sine();
            for _ in 0..5 {
                s.set_frequency(rand::gen_range(0..3) as f64);
                Beat(1, 2).delay().await;
            }
        }
        .seed(0)
        .spawn()
        .await;
    });
}

#[test]
fn scheduler_test() {
    start("scheduler_test", async {
        async {
            for _i in 0..10 {
                let s = osc::sine().with_frequency(now().as_f64());
                Beat(1, 2).delay().await;
                s.fin()
            }
        }
        .spawn_primary();

        async {
            for _i in 0..10 {
                let s = osc::pulse().with_frequency(now().as_f64());
                Beat(1, 4).delay().await;
                s.fin()
            }
        }
        .spawn_primary();
    })
}