wasm-bindgen/tests/all/js_globals/Generator.rs

#![allow(non_snake_case)]

use project;

#[test]
fn return_() {
    project()
        .file(
            "src/lib.rs",
            r#"
            #![feature(proc_macro, wasm_custom_section)]

            extern crate wasm_bindgen;
            use wasm_bindgen::prelude::*;
            use wasm_bindgen::js;

            #[wasm_bindgen]
            pub fn gen_return(this: &js::Generator, value: &JsValue) -> JsValue {
                this.return_(value)
            }
        "#,
        )
        .file(
            "test.ts",
            r#"
            import * as assert from "assert";
            import * as wasm from "./out";

            export function test() {
                function* generator() {
                    yield 1;
                    yield 2;
                }

                const gen = generator();
                gen.next();

                const res = wasm.gen_return(gen, 42);
                assert.deepEqual(res, { value: 42, done: true });

                const next = gen.next();
                assert.deepEqual(next, { value: undefined, done: true });
            }
        "#,
        )
        .test()
}

#[test]
fn next() {
    project()
        .file(
            "src/lib.rs",
            r#"
            #![feature(proc_macro, wasm_custom_section)]

            extern crate wasm_bindgen;
            use wasm_bindgen::prelude::*;
            use wasm_bindgen::js;

            #[wasm_bindgen]
            pub fn next(this: &js::Generator, value: &JsValue) -> JsValue {
                this.next(value)
                    .ok()
                    .expect("generator throws an error")
            }

            #[wasm_bindgen]
            pub fn next_throws_error(this: &js::Generator, value: &JsValue) -> bool {
                this.next(value).is_err()
            }
        "#,
        )
        .file(
            "test.ts",
            r#"
            import * as assert from "assert";
            import * as wasm from "./out";

            export function test() {
                function* generator() {
                    const reply = yield '2 * 2';

                    return reply === 4;
                }

                const gen = generator();

                const q = wasm.next(gen, undefined);
                assert.deepEqual(q, { value: '2 * 2', done: false });

                const a = wasm.next(gen, 4);
                assert.deepEqual(a, { value: true, done: true });

                function* brokenGenerator() {
                    throw new Error('Something went wrong');
                    yield 1;
                }

                assert(wasm.next_throws_error(brokenGenerator(), undefined));
            }
        "#,
        )
        .test()
}

#[test]
fn throw() {
    project()
        .file(
            "src/lib.rs",
            r#"
            #![feature(proc_macro, wasm_custom_section)]

            extern crate wasm_bindgen;
            use wasm_bindgen::prelude::*;
            use wasm_bindgen::js;

            #[wasm_bindgen]
            pub fn gen_throws_error(this: &js::Generator, error: &js::Error) -> bool {
                this.throw(error).is_err()
            }
        "#,
        )
        .file(
            "test.ts",
            r#"
            import * as assert from "assert";
            import * as wasm from "./out";

            export function test() {
                function* generator() {
                    yield 1;
                    yield 2;
                }

                const gen = generator();
                gen.next();

                assert(wasm.gen_throws_error(gen, new Error('Something went wrong')));
                assert.deepEqual(gen.next(), { value: undefined, done: true });
            }
        "#,
        )
        .test()
}