Add tests

Author: taiki-e

.travis.yml

@@ -84,6 +84,13 @@ matrix:
         - cargo run --manifest-path ci/remove-dev-dependencies/Cargo.toml */Cargo.toml
         - cargo build --manifest-path futures/Cargo.toml --features io-compat
 
+    - name: cargo test (async-stream feature)
+      rust: nightly
+      script:
+        - cargo test --manifest-path futures/Cargo.toml --features async-stream,nightly --test async_stream_tests
+        - cargo clean --manifest-path futures/testcrate/Cargo.toml
+        - cargo test --manifest-path futures/testcrate/Cargo.toml
+
     - name: cargo build --target=thumbv6m-none-eabi
       rust: nightly
       install:

futures/testcrate/Cargo.toml

@@ -2,16 +2,17 @@
 name = "testcrate"
 version = "0.1.0"
 authors = ["Alex Crichton <[email protected]>"]
+edition = "2018"
+publish = false
 
 [lib]
 path = "lib.rs"
 
-[dependencies.futures]
-features = ["std", "nightly"]
-path = ".."
+[dependencies]
+futures-preview = { path = "..", features = ["async-stream", "nightly"] }
 
 [dev-dependencies]
-compiletest_rs = "0.3.7"
+compiletest = { version = "0.3.21", package = "compiletest_rs", features = ["stable"] }
 
 [[test]]
 name = "ui"

futures/testcrate/lib.rs

@@ -0,0 +1 @@
+

futures/testcrate/tests/ui.rs

@@ -2,18 +2,24 @@ fn run_mode(mode: &'static str) {
     use std::env;
     use std::path::PathBuf;
 
-    let mut config = compiletest_rs::Config::default();
+    let mut config = compiletest::Config::default();
     config.mode = mode.parse().expect("invalid mode");
     let mut me = env::current_exe().unwrap();
     me.pop();
-    config.target_rustcflags = Some(format!("-L {}", me.display()));
+    config.target_rustcflags = Some(format!(
+        "--edition=2018 \
+         -Z unstable-options \
+         --extern futures \
+         -L {}",
+        me.display()
+    ));
     let src = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
     config.src_base = src.join(mode);
 
     me.pop();
     me.pop();
     config.build_base = me.join("tests").join(mode);
-    compiletest_rs::run_tests(&config);
+    compiletest::run_tests(&config);
 }
 
 fn main() {

futures/testcrate/ui/bad-input-1.rs

@@ -0,0 +1,13 @@
+#![feature(async_await, futures_api, generators)]
+
+use futures::*;
+
+#[async_stream]
+fn foo() -> i32 {
+    #[for_await]
+    for i in stream::iter(vec![1, 2]) {
+        stream_yield!(bar!!());
+    }
+}
+
+fn main() {}

futures/testcrate/ui/bad-input-1.stderr

@@ -0,0 +1,8 @@
+error: expected open delimiter
+ --> $DIR/bad-input-1.rs:9:27
+  |
+9 |         stream_yield!(bar!!());
+  |                           ^ expected open delimiter
+
+error: aborting due to previous error
+

futures/testcrate/ui/bad-input-2.rs

@@ -0,0 +1,22 @@
+
+#![feature(async_await, futures_api, generators)]
+
+use futures::*;
+
+#[async_stream]
+fn foo() -> i32 {
+    #[for_await(bar)]
+    for i in stream::iter(vec![1, 2]) {
+        stream_yield!(i);
+    }
+}
+
+#[async_stream(baz)]
+fn bar() -> i32 {
+    #[for_await]
+    for i in stream::iter(vec![1, 2]) {
+        stream_yield!(i);
+    }
+}
+
+fn main() {}

futures/testcrate/ui/bad-input-2.stderr

@@ -0,0 +1,14 @@
+error: attribute must be of the form `#[for_await]`
+ --> $DIR/bad-input-2.rs:8:5
+  |
+8 |     #[for_await(bar)]
+  |     ^^^^^^^^^^^^^^^^^
+
+error: attribute must be of the form `#[async_stream]`
+  --> $DIR/bad-input-2.rs:14:1
+   |
+14 | #[async_stream(baz)]
+   | ^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+

futures/testcrate/ui/bad-return-type.rs

@@ -1,33 +1,24 @@
-#![feature(proc_macro, generators)]
+#![feature(async_await, futures_api, generators)]
 
-#[async]
-fn foobar() -> Result<Option<i32>, ()> {
-    let val = Some(42);
-    if val.is_none() {
-        return Ok(None)
-    }
-    let val = val.unwrap();
-    Ok(val)
-}
+use futures::*;
 
-#[async_stream(item = Option<i32>)]
-fn foobars() -> Result<(), ()> {
+#[async_stream]
+fn foobar() -> Option<i32> {
     let val = Some(42);
     if val.is_none() {
         stream_yield!(None);
-        return Ok(())
+        return;
     }
     let val = val.unwrap();
     stream_yield!(val);
-    Ok(())
 }
 
-#[async]
-fn tuple() -> Result<(i32, i32), ()> {
+#[async_stream]
+fn tuple() -> (i32, i32) {
     if false {
-        return Ok(3);
+        stream_yield!(3);
     }
-    Ok((1, 2))
+    stream_yield!((1, 2))
 }
 
 fn main() {}