some expression/throw tests
diff --git a/Language/16_Expressions/09_Throw/from_async/assertion.txt b/Language/16_Expressions/09_Throw/from_async/assertion.txt
new file mode 100644
index 0000000..e46cf0c
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_async/assertion.txt
@@ -0,0 +1,4 @@
+Let f be the immediately enclosing function.
+If f is asynchronous then if there is a dynamically enclosing exception
+handler h introduced by the current activation, control is transferred to
+h, otherwise f terminates.
diff --git a/Language/16_Expressions/09_Throw/from_async/t01.dart b/Language/16_Expressions/09_Throw/from_async/t01.dart
new file mode 100644
index 0000000..cd3eb3f
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_async/t01.dart
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is asynchronous, and there is a
+ * dynamically enclosing exception handler h introduced by the current activation,
+ * control is transferred to h.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+f (int value) async {
+  try {
+    throw value;
+  } catch (e) {
+    return e+1;
+  }
+}
+
+test() async {
+  const int value=12345;
+  Future<int> res;
+  res = f(value);
+  await res.then((e)=>Expect.equals(value+1, e),
+    onError: (e)=>Expect.fail(e)
+  );
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/09_Throw/from_async/t02.dart b/Language/16_Expressions/09_Throw/from_async/t02.dart
new file mode 100644
index 0000000..b762f93
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_async/t02.dart
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is asynchronous generator, and there is a
+ * dynamically enclosing exception handler h introduced by the current activation,
+ * control is transferred to h.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+f (int value) async* {
+  try {
+    throw value;
+  } catch (e) {
+    yield e+1;
+  }
+}
+
+test() async {
+  const int value=12345;
+  Stream<int> res= f(value);
+  await res.listen((e)=>Expect.equals(value+1, e),
+    onError: (e)=>Expect.fail(e)
+  ).asFuture;
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/09_Throw/from_sync/assertion.txt b/Language/16_Expressions/09_Throw/from_sync/assertion.txt
new file mode 100644
index 0000000..9289adf
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_sync/assertion.txt
@@ -0,0 +1,4 @@
+Let f be the immediately enclosing function.
+If f is synchronous (9), control is transferred to the nearest dynamically
+enclosing exception handler.
+
diff --git a/Language/16_Expressions/09_Throw/from_sync/t01.dart b/Language/16_Expressions/09_Throw/from_sync/t01.dart
new file mode 100644
index 0000000..4fadfe9
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_sync/t01.dart
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if f is synchronous, control is transferred to
+ * the nearest dynamically enclosing exception handler
+ * @author kaigorodov
+ */
+
+import "package:expect/expect.dart";
+
+int f (int value) {
+  throw value;
+}
+
+int f1(int value) {
+  return f(value);
+}
+
+int f2(int value) {
+  return f1(value);
+}
+
+main() {
+  const int value=12345;
+  int res=-value;
+  try {
+    res=f(value);
+  } catch(e) {
+    Expect.equals(-value, res);
+    Expect.equals(value, e);
+  }
+  try {
+    res=f2(value);
+  } catch(e) {
+    Expect.equals(-value, res);
+    Expect.equals(value, e);
+  }
+}
diff --git a/Language/16_Expressions/09_Throw/from_syncstar/assertion.txt b/Language/16_Expressions/09_Throw/from_syncstar/assertion.txt
new file mode 100644
index 0000000..bc2b69c
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_syncstar/assertion.txt
@@ -0,0 +1,3 @@
+Let f be the immediately enclosing function.
+If f is marked sync* then a dynamically enclosing exception handler encloses
+the call to moveNext() that initiated the evaluation of the throw expression.
diff --git a/Language/16_Expressions/09_Throw/from_syncstar/t01.dart b/Language/16_Expressions/09_Throw/from_syncstar/t01.dart
new file mode 100644
index 0000000..859d8f1
--- /dev/null
+++ b/Language/16_Expressions/09_Throw/from_syncstar/t01.dart
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is marked sync* then a dynamically enclosing
+ * exception handler encloses the call to moveNext() that initiated the
+ * evaluation of the throw expression.
+ * @author kaigorodov
+ */
+import "package:expect/expect.dart";
+
+Iterable<int> f() sync* {
+  for (int i=0; i<5; i++) {
+    if (i==3) {
+      throw i;
+    }
+    yield i;
+  }
+}
+
+void main() {
+  Iterator<int> it=f().iterator;
+  for (int k=0; k<10; k++) {
+    try {
+      if (!it.moveNext()) {
+        break;
+      }
+      Expect.equals(k, it.current);
+    } catch (e) {
+      Expect.equals(k, e);
+    }
+  }
+}
+
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/assertion.txt b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/assertion.txt
new file mode 100644
index 0000000..9a3a6bb
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/assertion.txt
@@ -0,0 +1,7 @@
+When f [which is marked async*] terminates:
+• If the current return value is defined then, if s has been canceled then its
+cancellation future is completed with null.
+• If the current exception x is defined:
+– x is added to s.
+– If s has been canceled then its cancellation future is completed with x as an error.
+• s is closed.
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t01.dart b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t01.dart
new file mode 100644
index 0000000..da1e32f
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t01.dart
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that If the current return value is defined then, if s
+ * has been canceled then its cancellation future is completed with null.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+f (int value) async* {
+  for (int k=0; k<10; k++) { 
+     yield value;
+  }
+}
+
+test() async {
+  Stream<int> res= f(123);
+  StreamSubscription<int> subscr=res.listen(null);
+  Future fut=subscr.cancel();
+  Expect.isNotNull(fut);
+  return fut.then((v) => Expect.isNull(v));
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t02.dart b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t02.dart
new file mode 100644
index 0000000..6c8d751
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t02.dart
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that when async function f terminates, if the current
+ * exception x is defined:
+ *   x is added to s.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+var thrown=99;
+
+f () async* {
+   throw thrown;
+}
+
+test() async {
+  return f().listen((_){Expect.fail("onData not expected");},
+    onError: (e){Expect.equals(thrown, e);});
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t03.dart b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t03.dart
new file mode 100644
index 0000000..a053d55
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t03.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that when async function f terminates, if the current
+ * exception x is defined:
+ *   x is added to s and can be detected by subscription.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+var thrown=99;
+
+f () async* {
+   throw thrown;
+}
+
+test() async {
+  StreamSubscription<int> subscr=f().listen(null);
+  subscr.onData((_){Expect.fail("onData not expected");});
+  subscr.onError((e){Expect.equals(thrown, e);});
+  Completer completer = new Completer();
+  subscr.onDone((){completer.complete(null);});
+  return completer.future;
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t04.dart b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t04.dart
new file mode 100644
index 0000000..97b0b79
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates/t04.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that when async function f terminates, if the current
+ * exception x is defined:
+ *   x is added to s and can be detected by subscription, and the stream is closed..
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+var thrown=99;
+
+f () async* {
+   throw thrown;
+}
+
+test() async {
+  StreamSubscription<int> subscr=f().listen(null);
+  subscr.onData((_){Expect.fail("onData not expected");});
+  subscr.onError((e){Expect.equals(thrown, e);});
+  Completer completer = new Completer();
+  subscr.onDone((){completer.complete(null);});
+  return completer.future;
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates_innermost_first/assertion.txt b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates_innermost_first/assertion.txt
new file mode 100644
index 0000000..3716947
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates_innermost_first/assertion.txt
@@ -0,0 +1,4 @@
+If f is asynchronous then, when f terminates, any open stream subscriptions
+associated with any asynchronous for loops or yield-each statements
+executing within f are canceled, in the order of their nesting, innermost
+first.
diff --git a/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates_innermost_first/t01.dart b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates_innermost_first/t01.dart
new file mode 100644
index 0000000..26531c9
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/asyncstar_terminates_innermost_first/t01.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that when asynchronous function f terminates, any open
+ * stream subscriptions associated with any asynchronous for loops or yield-each
+ * statements executing within f are canceled, in the order of their nesting,
+ * innermost first.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+f (int value) async* {
+  for (int k=0; k<10; k++) { 
+     yield value;
+  }
+}
+
+test() async {
+  Stream<int> res= f(123);
+  StreamSubscription<int> subscr=res.listen(null);
+  Future fut=subscr.cancel();
+  Expect.isNotNull(fut);
+  return fut.then((v) => Expect.isNull(v));
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_async/assertion.txt b/Language/16_Expressions/14_Function_Invocation/invoke_async/assertion.txt
new file mode 100644
index 0000000..e7b74ed
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_async/assertion.txt
@@ -0,0 +1,6 @@
+If f is marked async, then a fresh instance o implementing the
+built-in class Future is associated with the invocation and immediately returned
+to the caller. The body of f is scheduled for execution at some future time. The
+future o will complete when f terminates. The value used to complete o is the
+current return value, if it is defined, and the current exception otherwise.
+
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_async/t01.dart b/Language/16_Expressions/14_Function_Invocation/invoke_async/t01.dart
new file mode 100644
index 0000000..f9f8bff
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_async/t01.dart
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is marked async, then an instance of class Future
+ * is returned to the caller. Checks that the body of f is not executed immediately.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+
+bool executed=false;
+
+f (int value) async {
+  executed=true;
+  return value;
+}
+
+main() {
+  Object res = f(12);
+  Expect.isTrue(res is Future, "actual: ${res.runtimeType}");
+  Expect.isFalse(executed);
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_async/t02.dart b/Language/16_Expressions/14_Function_Invocation/invoke_async/t02.dart
new file mode 100644
index 0000000..eec02de
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_async/t02.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is marked async, then The body of f
+ * is scheduled for execution at some future time. Checks that he value used
+ * to complete the future o is the current return value, if it is defined.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+f (int value) async {
+  return value;
+}
+
+test() async {
+  const int value=12345;
+  Future<int> res= f(value);
+  await res.then((e)=>Expect.equals(value, e),
+    onError: (e)=>Expect.fail(e)
+  );
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_async/t03.dart b/Language/16_Expressions/14_Function_Invocation/invoke_async/t03.dart
new file mode 100644
index 0000000..6245897
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_async/t03.dart
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is marked async, then The body of f
+ * is scheduled for execution at some future time. Checks that he value used
+ * to complete the future o is the current exception, if f is completed
+ * exceptionally.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+f (int value) async {
+  throw value;
+}
+
+test() async {
+  const int value=12345;
+  Future<int> res= f(value);
+  await res.then((e)=>Expect.fail(e),
+    onError: (e)=>Expect.equals(value, e)
+  );
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/assertion.txt b/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/assertion.txt
new file mode 100644
index 0000000..b72b0c9
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/assertion.txt
@@ -0,0 +1,3 @@
+If f is marked async*, then a fresh instance s implementing the built-in
+class Stream is associated with the invocation and immediately returned. When
+s is listened to, execution of the body of f will begin.
\ No newline at end of file
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/t01.dart b/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/t01.dart
new file mode 100644
index 0000000..6f2965d
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/t01.dart
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is marked async*, then an instance of class Stream
+ * is returned to the caller. Checks that the body of f is not executed immediately.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+
+bool executed=false;
+
+f (int value) async* {
+  executed=true;
+  yield value;
+}
+
+main() {
+  Object res = f(12);
+  Expect.isTrue(res is Stream, "actual: ${res.runtimeType}");
+  Expect.isFalse(executed);
+}
diff --git a/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/t02.dart b/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/t02.dart
new file mode 100644
index 0000000..ba32dfc
--- /dev/null
+++ b/Language/16_Expressions/14_Function_Invocation/invoke_asyncstar/t02.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @description Checks that if function f is marked async*, then
+ * execution of the body of f will begin when the stream is listened to.
+ * @author kaigorodov
+ */
+import "dart:async";
+import "package:expect/expect.dart";
+import "package:async_helper/async_helper.dart";
+
+bool executed=false;
+
+f (int value) async* {
+  executed=true;
+  yield value;
+}
+
+test() async {
+  Stream<int> res= f(123);
+  await res.listen((_){ Expect.isTrue(executed);}
+  ).asFuture;
+}
+
+main() {
+  asyncStart();
+  test().then((_) => asyncEnd());
+}
diff --git a/toAsktxt b/toAsktxt
new file mode 100644
index 0000000..adb2ee8
--- /dev/null
+++ b/toAsktxt
@@ -0,0 +1,5 @@
+1. can we to use import "package:expect/expect.dart", as used in dart-build tests?
+  it works, but that lib has no async utils (asyncStart, asyncEnd); How to test async tests? There may be asyncStart but no reaction.
+2. test layout:
+Language/16_Expressions/9_throw/fromAsync/{ assertion.txt t01.dart t02.dart } 
+the goal is to easily maintain spec changes
\ No newline at end of file