diff --git a/tests/basics/builtin_chr.py b/tests/basics/builtin_chr.py
new file mode 100644
index 0000000000000000000000000000000000000000..02d783ae667dda1909d247d0f7958f69cd0e3dd3
--- /dev/null
+++ b/tests/basics/builtin_chr.py
@@ -0,0 +1,9 @@
+# test builtin chr (whether or not we support unicode)
+
+print(chr(65))
+
+try:
+    chr(0x110000)
+except ValueError:
+    print("ValueError")
+
diff --git a/tests/basics/builtin_compile.py b/tests/basics/builtin_compile.py
index ef3ff014d49af580711bfea5a09405582a8d4388..32c6667d8b1af4e0066f37fa665f792bc3b8384b 100644
--- a/tests/basics/builtin_compile.py
+++ b/tests/basics/builtin_compile.py
@@ -7,10 +7,9 @@ def have_compile():
     except NameError:
         return False
 
-# global variable for compiled code to access
-x = 1
-
 def test():
+    global x
+
     c = compile("print(x)", "file", "exec")
 
     try:
@@ -18,11 +17,31 @@ def test():
     except NameError:
         print("NameError")
 
+    # global variable for compiled code to access
+    x = 1
+
     exec(c)
 
     exec(c, {"x":2})
     exec(c, {}, {"x":3})
 
+    # single/eval mode
+    exec(compile('print(1 + 1)', 'file', 'single'))
+    print(eval(compile('1 + 1', 'file', 'eval')))
+
+    # bad mode
+    try:
+        compile('1', 'file', '')
+    except ValueError:
+        print("ValueError")
+
+    # exception within compiled code
+    try:
+        exec(compile('noexist', 'file', 'exec'))
+    except NameError:
+        print("NameError")
+    print(x) # check 'x' still exists as a global
+
 if have_compile():
     test()
 else:
diff --git a/tests/basics/builtin_dir.py b/tests/basics/builtin_dir.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7064c8caba21d26848d3bced751a57b50298623
--- /dev/null
+++ b/tests/basics/builtin_dir.py
@@ -0,0 +1,9 @@
+# test builtin dir
+
+# dir of locals
+print('__name__' in dir())
+
+# dir of module
+import sys
+print('platform' in dir(sys))
+
diff --git a/tests/basics/builtin_divmod.py b/tests/basics/builtin_divmod.py
new file mode 100644
index 0000000000000000000000000000000000000000..f159691b7ba0a65edd75f4b82c643eeee85da587
--- /dev/null
+++ b/tests/basics/builtin_divmod.py
@@ -0,0 +1,16 @@
+# test builtin divmod
+
+print(divmod(0, 2))
+print(divmod(3, 4))
+print(divmod(20, 3))
+
+try:
+    divmod(1, 0)
+except ZeroDivisionError:
+    print("ZeroDivisionError")
+
+try:
+    divmod('a', 'b')
+except TypeError:
+    print("TypeError")
+
diff --git a/tests/basics/builtin_minmax.py b/tests/basics/builtin_minmax.py
index a5f035b9094e2b787a6de2ce4c92d459e51abe92..e2bb0ed7b04fd4edb0a08fdf12ba68d5a0db899b 100644
--- a/tests/basics/builtin_minmax.py
+++ b/tests/basics/builtin_minmax.py
@@ -23,3 +23,9 @@ print(max(lst, key=lambda x:x))
 print(max(lst, key=lambda x:-x))
 print(max(1, 2, 3, 4, key=lambda x:-x))
 print(max(4, 3, 2, 1, key=lambda x:-x))
+
+# need at least 1 item in the iterable
+try:
+    min([])
+except ValueError:
+    print("ValueError")
diff --git a/tests/basics/builtin_ord.py b/tests/basics/builtin_ord.py
new file mode 100644
index 0000000000000000000000000000000000000000..6347aa4ec04b282f6e4eeb4f6f54c298d2607df5
--- /dev/null
+++ b/tests/basics/builtin_ord.py
@@ -0,0 +1,9 @@
+# test builtin ord (whether or not we support unicode)
+
+print(ord('a'))
+
+try:
+    ord('')
+except TypeError:
+    print("TypeError")
+
diff --git a/tests/basics/builtin_pow.py b/tests/basics/builtin_pow.py
new file mode 100644
index 0000000000000000000000000000000000000000..a19ab8c843b77a24ce785f5f5213a739d2a0a1fc
--- /dev/null
+++ b/tests/basics/builtin_pow.py
@@ -0,0 +1,11 @@
+# test builtin pow() with integral values
+
+# 2 arg version
+print(pow(0, 1))
+print(pow(1, 0))
+print(pow(-2, 3))
+print(pow(3, 8))
+
+# 3 arg version
+print(pow(3, 4, 7))
+
diff --git a/tests/basics/property.py b/tests/basics/builtin_property.py
similarity index 64%
rename from tests/basics/property.py
rename to tests/basics/builtin_property.py
index 7f3c833ad3f5fba11e870c87be56acc2ec1cadc8..4df9842a3e40a7b2a143d57529408f9815ebd34a 100644
--- a/tests/basics/property.py
+++ b/tests/basics/builtin_property.py
@@ -1,3 +1,16 @@
+# test builtin property
+
+# create a property object explicitly
+property()
+property(1, 2, 3)
+
+# use its accessor methods
+p = property()
+p.getter(1)
+p.setter(2)
+p.deleter(3)
+
+# basic use as a decorator
 class A:
     def __init__(self, x):
         self._x = x
@@ -15,6 +28,7 @@ try:
 except AttributeError:
     print("AttributeError")
 
+# explicit use within a class
 class B:
     def __init__(self, x):
         self._x = x
@@ -27,13 +41,18 @@ class B:
         print("x set")
         self._x = value
 
-    x = property(xget, xset)
+    def xdel(self):
+        print("x del")
+
+    x = property(xget, xset, xdel)
 
 b = B(3)
 print(b.x)
 b.x = 4
 print(b.x)
+del b.x
 
+# full use as a decorator
 class C:
     def __init__(self, x):
         self._x = x
@@ -48,7 +67,12 @@ class C:
         print("x set")
         self._x = value
 
+    @x.deleter
+    def x(self):
+        print("x del")
+
 c = C(5)
 print(c.x)
 c.x = 6
 print(c.x)
+del c.x
diff --git a/tests/basics/builtin_slice.py b/tests/basics/builtin_slice.py
new file mode 100644
index 0000000000000000000000000000000000000000..4da1229fa025c792d0aa392a32672b5e6aba68d9
--- /dev/null
+++ b/tests/basics/builtin_slice.py
@@ -0,0 +1,7 @@
+# test builtin slice
+
+# print slice
+class A:
+    def __getitem__(self, idx):
+        print(idx)
+A()[1:2:3]
diff --git a/tests/basics/builtin_sorted.py b/tests/basics/builtin_sorted.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4f71a15ebeb2f97db3ce3fafa0e2949728df591
--- /dev/null
+++ b/tests/basics/builtin_sorted.py
@@ -0,0 +1,10 @@
+# test builtin sorted
+
+print(sorted(set(range(100))))
+print(sorted(set(range(100)), key=lambda x: x + 100*(x % 2)))
+
+# need to use keyword argument
+try:
+    sorted([], None)
+except TypeError:
+    print("TypeError")
diff --git a/tests/basics/class_descriptor.py b/tests/basics/class_descriptor.py
index 27907411db95e79cac9fe4fb739e8c3e51af97ee..25b373e47e636f452455e44ee53cf79a2bca24f9 100644
--- a/tests/basics/class_descriptor.py
+++ b/tests/basics/class_descriptor.py
@@ -1,13 +1,19 @@
 class Descriptor:
     def __get__(self, obj, cls):
+        print('get')
         print(type(obj) is Main)
         print(cls is Main)
         return 'result'
 
     def __set__(self, obj, val):
+        print('set')
         print(type(obj) is Main)
         print(val)
 
+    def __delete__(self, obj):
+        print('delete')
+        print(type(obj) is Main)
+
 class Main:
     Forward = Descriptor()
 
@@ -18,4 +24,5 @@ if 'Descriptor' in repr(r.__class__):
 else:
     print(r)
     m.Forward = 'a'
+    del m.Forward
 
diff --git a/tests/basics/fun_error.py b/tests/basics/fun_error.py
new file mode 100644
index 0000000000000000000000000000000000000000..02af7b1bba0a12430b9c6c00275eaf8ec483f961
--- /dev/null
+++ b/tests/basics/fun_error.py
@@ -0,0 +1,31 @@
+# test errors from bad function calls
+
+def test_exc(code, exc):
+    try:
+        exec(code)
+        print("no exception")
+    except exc:
+        print("right exception")
+    except:
+        print("wrong exception")
+
+# function doesn't take keyword args
+test_exc("[].append(x=1)", TypeError)
+
+# function with variable number of positional args given too few
+test_exc("round()", TypeError)
+
+# function with variable number of positional args given too many
+test_exc("round(1, 2, 3)", TypeError)
+
+# function with fixed number of positional args given wrong number
+test_exc("[].append(1, 2)", TypeError)
+
+# function with keyword args given extra positional args
+test_exc("[].sort(1)", TypeError)
+
+# function with keyword args given extra keyword args
+test_exc("[].sort(noexist=1)", TypeError)
+
+# function with keyword args not given a specific keyword arg
+test_exc("enumerate()", TypeError)
diff --git a/tests/basics/int_big_mul.py b/tests/basics/int_big_mul.py
index f8d3dcd8007213c00c1005d5f264eddf5d3e5683..6010075c4e1ea3fbe36074545ef957ddf074d7e2 100644
--- a/tests/basics/int_big_mul.py
+++ b/tests/basics/int_big_mul.py
@@ -6,3 +6,18 @@ for rhs in range(2, 11):
         print(lhs, '*', rhs, '=', res)
         lhs = res
 
+# below tests pos/neg combinations that overflow small int
+
+# 31-bit overflow
+i = 1 << 20
+print(i * i)
+print(i * -i)
+print(-i * i)
+print(-i * -i)
+
+# 63-bit overflow
+i = 1 << 40
+print(i * i)
+print(i * -i)
+print(-i * i)
+print(-i * -i)
diff --git a/tests/basics/module1.py b/tests/basics/module1.py
new file mode 100644
index 0000000000000000000000000000000000000000..c158af52e2e6d2705701e60c7402db3ce7ddda7e
--- /dev/null
+++ b/tests/basics/module1.py
@@ -0,0 +1,13 @@
+# test behaviour of module objects
+
+# this module should always exist
+import __main__
+
+# print module
+print(repr(__main__).startswith("<module '__main__'"))
+
+# store new attribute
+__main__.x = 1
+
+# delete attribute
+del __main__.x
diff --git a/tests/basics/module2.py b/tests/basics/module2.py
new file mode 100644
index 0000000000000000000000000000000000000000..a135601579cd7bb484bd29f7b704c3b591605773
--- /dev/null
+++ b/tests/basics/module2.py
@@ -0,0 +1,6 @@
+# uPy behaviour only: builtin modules are read-only
+import sys
+try:
+    sys.x = 1
+except AttributeError:
+    print("AttributeError")
diff --git a/tests/basics/module2.py.exp b/tests/basics/module2.py.exp
new file mode 100644
index 0000000000000000000000000000000000000000..d169edffb4cfb4a3cd208e5e3118e67fe59f6f4d
--- /dev/null
+++ b/tests/basics/module2.py.exp
@@ -0,0 +1 @@
+AttributeError
diff --git a/tests/basics/object1.py b/tests/basics/object1.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbc7e92eadb0094aa33a81720374fcd7a15e6959
--- /dev/null
+++ b/tests/basics/object1.py
@@ -0,0 +1,7 @@
+# test builtin object()
+
+# creation
+object()
+
+# printing
+print(repr(object())[:7])
diff --git a/tests/basics/op_error.py b/tests/basics/op_error.py
index cfd6ffa8c468a06c8e18c7be411171d954312b09..19ce04bc520ce2af16e94bb260feacfd0106f50b 100644
--- a/tests/basics/op_error.py
+++ b/tests/basics/op_error.py
@@ -11,6 +11,7 @@ def test_exc(code, exc):
 
 # unsupported unary operators
 test_exc("~None", TypeError)
+test_exc("~''", TypeError)
 test_exc("~[]", TypeError)
 test_exc("~bytearray()", TypeError)
 
@@ -28,6 +29,8 @@ test_exc("(1 << 70) in 1", TypeError)
 # unsupported subscription
 test_exc("1[0]", TypeError)
 test_exc("1[0] = 1", TypeError)
+test_exc("''['']", TypeError)
+test_exc("'a'[0] = 1", TypeError)
 test_exc("del 1[0]", TypeError)
 
 # not callable
diff --git a/tests/basics/sorted.py b/tests/basics/sorted.py
deleted file mode 100644
index bbec31946059c54ee1e241bc731a43c83b9e8393..0000000000000000000000000000000000000000
--- a/tests/basics/sorted.py
+++ /dev/null
@@ -1,2 +0,0 @@
-print(sorted(set(range(100))))
-print(sorted(set(range(100)), key=lambda x: x + 100*(x % 2)))
diff --git a/tests/basics/string1.py b/tests/basics/string1.py
index b617cc786db5df8310c5718d48e28f08c69a444a..f58fcd401a457dccf2b5a4abf7a8e8471ee92c00 100644
--- a/tests/basics/string1.py
+++ b/tests/basics/string1.py
@@ -26,9 +26,11 @@ except IndexError:
 # iter
 print(list('str'))
 
+# comparison
 print('123' + '789' == '123789')
 print('a' + 'b' != 'a' + 'b ')
+print('1' + '2' > '2')
+print('1' + '2' < '2')
 
-# Not implemented so far
-# print('1' + '2' > '2')
-# print('1' + '2' < '2')
+# printing quote char in string
+print(repr('\'\"'))
diff --git a/tests/basics/sys1.py b/tests/basics/sys1.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa81e14ecda48dff8539775f87df344841499626
--- /dev/null
+++ b/tests/basics/sys1.py
@@ -0,0 +1,21 @@
+# test sys module
+
+import sys
+
+print(sys.__name__)
+print(type(sys.path))
+print(type(sys.argv))
+print(sys.version[:3])
+print(sys.version_info[0], sys.version_info[1])
+print(sys.byteorder in ('little', 'big'))
+print(sys.maxsize > 100)
+
+try:
+    sys.exit()
+except SystemExit as e:
+    print("SystemExit", e.args)
+
+try:
+    sys.exit(42)
+except SystemExit as e:
+    print("SystemExit", e.args)
diff --git a/tests/cmdline/repl_cont.py b/tests/cmdline/repl_cont.py
new file mode 100644
index 0000000000000000000000000000000000000000..66a484ce3d4b4fe1979a486e16e9887ea83b6eac
--- /dev/null
+++ b/tests/cmdline/repl_cont.py
@@ -0,0 +1,21 @@
+# check REPL allows to continue input
+1 \
++ 2
+'abc'
+"abc"
+'''abc
+def'''
+"""ABC
+DEF"""
+print(
+1 + 2)
+l = [1,
+2]
+print(l)
+d = {1:'one',
+2:'two'}
+print(d[2])
+def f(x):
+ print(x)
+
+f(3)
diff --git a/tests/cmdline/repl_cont.py.exp b/tests/cmdline/repl_cont.py.exp
new file mode 100644
index 0000000000000000000000000000000000000000..2405e601cb3c35efc31b36c3f3f67815d01951cf
--- /dev/null
+++ b/tests/cmdline/repl_cont.py.exp
@@ -0,0 +1,32 @@
+Micro Python \.\+ linux version
+>>> # check REPL allows to continue input
+>>> 1 \
+... + 2
+3
+>>> 'abc'
+'abc'
+>>> "abc"
+'abc'
+>>> '''abc
+... def'''
+'abc\ndef'
+>>> """ABC
+... DEF"""
+'ABC\nDEF'
+>>> print(
+... 1 + 2)
+3
+>>> l = [1,
+... 2]
+>>> print(l)
+[1, 2]
+>>> d = {1:'one',
+... 2:'two'}
+>>> print(d[2])
+two
+>>> def f(x):
+...  print(x)
+... 
+>>> f(3)
+3
+>>> 
diff --git a/tests/float/builtin_float_round.py b/tests/float/builtin_float_round.py
index afde6ff16c08973e4e66d8cfa5dfdbf80ab3a5c6..6759d0fd5a3ef40dc0fc57b7f3efc6d1025aa00d 100644
--- a/tests/float/builtin_float_round.py
+++ b/tests/float/builtin_float_round.py
@@ -10,3 +10,7 @@ for t in tests:
 # check .5 cases
 for i in range(11):
     print(round((i - 5) / 2))
+
+# test second arg
+# TODO uPy currently only supports second arg being 0
+print(round(1.4, 0))
diff --git a/tests/float/complex1.py b/tests/float/complex1.py
index eafa53746abe82e952f61e28acc5f0b134262a62..2fb95c69081ae51fff46edade2e2e88c5ff9be87 100644
--- a/tests/float/complex1.py
+++ b/tests/float/complex1.py
@@ -33,6 +33,9 @@ ans = 1j ** 2.5j; print("%.5g %.5g" % (ans.real, ans.imag))
 print(abs(1j))
 print("%.5g" % abs(1j + 2))
 
+# float on lhs should delegate to complex
+print(1.2 + 3j)
+
 # convert bignum to complex on rhs
 ans = 1j + (1 << 70); print("%.5g %.5g" % (ans.real, ans.imag))
 
diff --git a/tests/float/float1.py b/tests/float/float1.py
index 9e4bb85cd10ee1b0803f6528a3809f34f2ae4e18..2539d89dc3f5e2aa0c31e01fccc640931a6a4259 100644
--- a/tests/float/float1.py
+++ b/tests/float/float1.py
@@ -1,4 +1,15 @@
-# basic float
+# test basic float capabilities
+
+# float construction
+print(float(1.2))
+
+# unary operators
+print(bool(0.0))
+print(bool(1.2))
+print(+(1.2))
+print(-(1.2))
+
+# division of integers
 x = 1 / 2
 print(x)
 
@@ -7,9 +18,16 @@ a = 1
 a /= 2
 print(a)
 
+# floor division
 print(1.0 // 2)
 print(2.0 // 2)
 
+# comparison
+print(1.2 <= 3.4)
+print(1.2 <= -3.4)
+print(1.2 >= 3.4)
+print(1.2 >= -3.4)
+
 try:
     1.0 / 0
 except ZeroDivisionError:
@@ -20,6 +38,23 @@ try:
 except ZeroDivisionError:
     print("ZeroDivisionError")
 
+try:
+    1.2 % 0
+except ZeroDivisionError:
+    print("ZeroDivisionError")
+
+# unsupported unary ops
+
+try:
+    ~1.2
+except TypeError:
+    print("TypeError")
+
+try:
+    1.2 in 3.4
+except TypeError:
+    print("TypeError")
+
 # can't convert list to float
 try:
     float([])
diff --git a/tests/float/math_fun.py b/tests/float/math_fun.py
index 03ee8e85d23bb7c08ae83d180df5ea665ef15b0a..16aec76f92a1042e6d3c28a849dd4e098f795ed6 100644
--- a/tests/float/math_fun.py
+++ b/tests/float/math_fun.py
@@ -33,7 +33,9 @@ functions = [('sqrt', sqrt, p_test_values),
              ('ceil', ceil, test_values),
              ('fabs', fabs, test_values),
              ('floor', floor, test_values),
-             ('trunc', trunc, test_values)
+             ('trunc', trunc, test_values),
+             ('radians', radians, test_values),
+             ('degrees', degrees, test_values),
             ]
 
 for function_name, function, test_vals in functions:
@@ -52,10 +54,14 @@ for function_name, function, test_vals in tuple_functions:
         print("{:.5g} {:.5g}".format(x, y))
 
 binary_functions = [('copysign', copysign, [(23., 42.), (-23., 42.), (23., -42.),
-                                (-23., -42.), (1., 0.0), (1., -0.0)])
+                                (-23., -42.), (1., 0.0), (1., -0.0)]),
+                    ('pow', pow, ((1., 0.), (0., 1.), (2., 0.5), (-3., 5.), (-3., -4.),)),
+                    ('atan2', atan2, ((1., 0.), (0., 1.), (2., 0.5), (-3., 5.), (-3., -4.),)),
+                    ('fmod', fmod, ((1., 1.), (0., 1.), (2., 0.5), (-3., 5.), (-3., -4.),)),
+                    ('ldexp', ldexp, ((1., 0), (0., 1), (2., 2), (3., -2), (-3., -4),)),
                    ]
 
 for function_name, function, test_vals in binary_functions:
     print(function_name)
     for value1, value2 in test_vals:
-        print("{:.7g}".format(function(value1, value2)))
+        print("{:.5g}".format(function(value1, value2)))
diff --git a/tests/io/stringio1.py b/tests/io/stringio1.py
index dae0187f8846482fe0cb5c8dabc2fa1adecd8e8e..22f561f2990910224bf4b204ac23f693bb1ea93e 100644
--- a/tests/io/stringio1.py
+++ b/tests/io/stringio1.py
@@ -1,6 +1,7 @@
 import _io as io
 
 a = io.StringIO()
+print('io.StringIO' in repr(a))
 print(a.getvalue())
 print(a.read())
 
diff --git a/tests/io/stringio_with.py b/tests/io/stringio_with.py
new file mode 100644
index 0000000000000000000000000000000000000000..becb564dfdd7ad5d7aad48397c661a7054321a01
--- /dev/null
+++ b/tests/io/stringio_with.py
@@ -0,0 +1,6 @@
+import _io as io
+
+# test __enter__/__exit__
+with io.StringIO() as b:
+    b.write("foo")
+    print(b.getvalue())
diff --git a/tests/micropython/meminfo.py b/tests/micropython/meminfo.py
new file mode 100644
index 0000000000000000000000000000000000000000..698bbbd21cacd5f868e7ef63c50171e93b6615cd
--- /dev/null
+++ b/tests/micropython/meminfo.py
@@ -0,0 +1,12 @@
+# tests meminfo functions in micropython module
+
+import micropython
+
+# these functions are not always available
+if not hasattr(micropython, 'mem_info'):
+    print('SKIP')
+else:
+    micropython.mem_info()
+    micropython.mem_info(1)
+    micropython.qstr_info()
+    micropython.qstr_info(1)
diff --git a/tests/micropython/meminfo.py.exp b/tests/micropython/meminfo.py.exp
new file mode 100644
index 0000000000000000000000000000000000000000..31a97c3e4388585fe3e9d0ef7c931a364ad6e858
--- /dev/null
+++ b/tests/micropython/meminfo.py.exp
@@ -0,0 +1,14 @@
+mem: total=\\d\+, current=\\d\+, peak=\\d\+
+stack: \\d\+ out of \\d\+
+GC: total: \\d\+, used: \\d\+, free: \\d\+
+ No. of 1-blocks: \\d\+, 2-blocks: \\d\+, max blk sz: \\d\+
+mem: total=\\d\+, current=\\d\+, peak=\\d\+
+stack: \\d\+ out of \\d\+
+GC: total: \\d\+, used: \\d\+, free: \\d\+
+ No. of 1-blocks: \\d\+, 2-blocks: \\d\+, max blk sz: \\d\+
+GC memory layout; from 0x\[0-9a-f\]\+:
+########
+qstr pool: n_pool=1, n_qstr=\\d, n_str_data_bytes=\\d\+, n_total_bytes=\\d\+
+qstr pool: n_pool=1, n_qstr=\\d, n_str_data_bytes=\\d\+, n_total_bytes=\\d\+
+########
+Q(SKIP)
diff --git a/tests/micropython/memstats.py b/tests/micropython/memstats.py
new file mode 100644
index 0000000000000000000000000000000000000000..78e4d24736daf3d3d783cad28df343b8fccb6009
--- /dev/null
+++ b/tests/micropython/memstats.py
@@ -0,0 +1,17 @@
+# tests meminfo functions in micropython module
+
+import micropython
+
+# these functions are not always available
+if not hasattr(micropython, 'mem_total'):
+    print('SKIP')
+else:
+    t = micropython.mem_total()
+    c = micropython.mem_current()
+    p = micropython.mem_peak()
+
+    l = list(range(10000))
+
+    print(micropython.mem_total() > t)
+    print(micropython.mem_current() > c)
+    print(micropython.mem_peak() > p)
diff --git a/tests/micropython/memstats.py.exp b/tests/micropython/memstats.py.exp
new file mode 100644
index 0000000000000000000000000000000000000000..b8ca7e7ef092aae1d0b2628ea64f242051385c8c
--- /dev/null
+++ b/tests/micropython/memstats.py.exp
@@ -0,0 +1,3 @@
+True
+True
+True
diff --git a/tests/run-tests b/tests/run-tests
index 385c4e696df243d7ab75b26ba37ca97c11e80b9a..03f149b9eb41ff22d53ebc5208242c322a3e6380 100755
--- a/tests/run-tests
+++ b/tests/run-tests
@@ -29,7 +29,7 @@ def rm_f(fname):
 def run_micropython(pyb, args, test_file):
     if pyb is None:
         # run on PC
-        if test_file.startswith('cmdline/'):
+        if test_file.startswith('cmdline/') or test_file == 'micropython/meminfo.py':
             # special handling for tests of the unix cmdline program
 
             # check for any cmdline options needed for this test
@@ -141,6 +141,7 @@ def run_tests(pyb, tests, args):
     if pyb is not None:
         skip_tests.add('float/float_divmod.py') # tested by float/float_divmod_relaxed.py instead
         skip_tests.add('float/float2int_doubleprec.py') # requires double precision floating point to work
+        skip_tests.add('micropython/meminfo.py') # output is very different to PC output
 
     # Some tests are known to fail on 64-bit machines
     if pyb is None and platform.architecture()[0] == '64bit':
@@ -162,6 +163,7 @@ def run_tests(pyb, tests, args):
         skip_tests.add('float/cmath_fun.py') # requires f(*args) support
         skip_tests.add('import/gen_context.py')
         skip_tests.add('io/file_with.py')
+        skip_tests.add('io/stringio_with.py')
         skip_tests.add('micropython/heapalloc.py')
         skip_tests.add('misc/features.py')
         skip_tests.add('misc/recursion.py')
diff --git a/tests/unicode/unicode.py b/tests/unicode/unicode.py
index c7e523f06a5f134f3192f763c239788519164849..57075f7e3e42911bf06daeb4d9f6e011de7a51a8 100644
--- a/tests/unicode/unicode.py
+++ b/tests/unicode/unicode.py
@@ -16,3 +16,7 @@ for i in range(-len(s), len(s)):
 # Test UTF-8 encode and decode
 enc = s.encode()
 print(enc, enc.decode() == s)
+
+# printing of unicode chars using repr
+# TODO we don't do this correctly
+#print(repr(s))
diff --git a/tests/unicode/unicode_chr.py b/tests/unicode/unicode_chr.py
new file mode 100644
index 0000000000000000000000000000000000000000..248eb5892fabfe91c8ea8a052ce0a6bb7f407bb6
--- /dev/null
+++ b/tests/unicode/unicode_chr.py
@@ -0,0 +1,5 @@
+# test builtin chr with unicode characters
+
+print(chr(945))
+print(chr(0x800))
+print(chr(0x10000))
diff --git a/tests/unicode/unicode_ord.py b/tests/unicode/unicode_ord.py
new file mode 100644
index 0000000000000000000000000000000000000000..47cfa1c2d7cdf0406c8b2143176bd7b34064fd2f
--- /dev/null
+++ b/tests/unicode/unicode_ord.py
@@ -0,0 +1,3 @@
+# test builtin ord with unicode characters
+
+print(ord('α'))