Merge tag 'v1.9' into parse-bytecode

New VFS subsystem and scheduling framework, and less need for the heap

This release adds some fundamental new components, allows for more Python
operations without using the heap and has reduced code size and stack
usage.

Changes in the way iterators are handled allows to iterate without
allocating on the heap for the types: tuple, list, str, bytes, bytearray,
array, dict, set, frozenset.  It also allows to call the builtins all, any,
min max and sum without allocating heap memory for the iterator argument.
And improvements to the handling of super() means that super().foo() method
calls are now heap-less.

A new generic VFS subsystem has been added which allows to mount arbitrary
filesystems (even written in Python) at the root or at a mount-point within
the root.  The FatFS driver has been replaced with an object-oriented
version (oofatfs) which allows a fully customisable filesystem layout.

A scheduling framework has been implemented in the core which gives the
ability to schedule callbacks to be called "as soon as possible".  This
allows ports to implement "soft IRQs" which allow the programmer to
allocate memory during an interrupt handler, at the cost of some
performance related to response time of the handler.  The new
micropython.schedule() function gives access to the scheduler.

Other improvements to the core include: consts can now be big-nums, for
example "X = const(1 << 100)"; addition of "help('modules')" to list
available modules; stack usage reduced for a Python call by 8 bytes on ARM
Cortex-M architectures; micropython.kbd_intr() function added to disable
Ctrl-C capture; addition of uio.resource_stream(); mpy-cross is built
automatically if needed; a helper tool mpy_cross_all.py is added to run
mpy-cross on an entire project.

The bytecode has changed in this version so existing .mpy files will need
recompiling.  There have also been some changes to the C API, most notably
with mp_uint_t changed to size_t in many places.

In the extended modules the following main changes have been made: addition
of machine.Signal class to allow inversion on a Pin; framebuf has new
formats of the form MONO_xxx; addition of uselect.ipoll() for allocation-
free polling; addition of uos.ilistdir() for efficient iteration of a
directory listing; machine.Pin high/low methods are renamed to on/off in
esp8266 and zephyr (this is a backwards-incompatible change);
machine.time_pulse_us() function no longer throws exceptions, but returns
negative values instead.

For stmhal the pyb.fault_debug() function is added, and default behaviour
for a hard-fault is now an immediate reset.  There is better support for F7
MCUs, in particular DMA and SD card support.  A bug has been fixed with the
USB VCP (USB serial) where it would in rare cases (usually when the host PC
was under load) would lose characters.  Pyboard now automatically mounts
all available partitions on the SD card.  Multithreading has been
implemented and is available via the _thread module, but this feature is
disabled by default and must be enabled at compile time using the
MICROPY_THREAD and MICROPY_THREAD_GIL options.  The ability to skip booting
from SD card is now available by creating an empty file on the flash called
"SKIPSD".

The cc3200 port has had some backwards incompatible changes, in particular
with I2C, Pin, UART and uos.  Please see the documentation for the new
behaviour.

The esp8266 port has had a change in the size of the firmware in order to
accommodate additional features.  As such the filesystem for this version
is incompatible with v1.8.7 and a device requires backup and erasure before
flashing this version.  Soft IRQs are now implemented for Pin and Timer
callbacks, along with the general improvements described above.

In the documentation there is now a section describing the differences
between MicroPython and CPython.  And code coverage is up to 98% across py/
and extmod/.

Changes in code size (in bytes) between v1.8.7 and this version are:

   bare-arm: -1104
    minimal: -1324
   unix x64: -1115
unix nanbox: -11106
     stmhal: +18116
     cc3200: +1032
    esp8266: +3060

Note that stmhal has increased significantly due to the addition of frozen
bytecode and the LCD160CR driver.

A detailed list of changes follows.

py core:
- builtinimport: raise ValueError for bad relative import, per CPython
- builtinimport: remove unreachable code and change obj-import comment
- runtime: refactor assert(0) to improve coverage
- runtime: fix handling of throw() when resuming generator
- objgenerator: when throwing an object, don't make an exc instance
- objgenerator: don't raise RuntimeError if GeneratorExit ignored
- parse: refactor code to remove assert(0)'s
- emitnative: remove assert(0)'s or replace with mp_not_implemented
- objexcept: replace if-cond and assert(0) with simple assert
- runtime: refactor default case of switch to remove assert(0)
- binary: mp_binary_get_size: Raise error on unsupported typecodes
- formatfloat: remove unreachable code
- objint_mpz: refactor switch-statement to remove unreachable default
- mpz: implement mpz_set_from_bytes() as a foundation for int.from_bytes()
- objint: from_bytes(): implement "byteorder" param and arbitrary precision
- objint_longlong: add stub for mp_obj_int_from_bytes_impl()
- add builtin help function to core, with default help msg
- move weak-link map to objmodule.c, and expose module maps as public
- builtinhelp: implement help('modules') to list available modules
- objint: fix left-shift overflow in checking for large int
- objmodule: move module init/deinit code into runtime functions
- objstr: optimize string concatenation with empty string
- showbc: make sure to set the const_table before printing bytecode
- py.mk: add CFLAGS_MOD flag to set config file for FatFs
- objstringio: allow to specify initial capacity by passing numeric argument
- objset: make inplace binary operators actually modify the set
- objfloat: raise ZeroDivisionError for 0 to negative power
- objcomplex: correctly handle case of 0j to power of something
- objset: fix inplace binary ops so frozensets are not modified
- added optimised support for 3-argument calls to builtin.pow()
- objstr: give correct behaviour when passing a dict to %-formatting
- mpconfig.h: move PY_BUILTINS_POW3 config option to diff part of file
- objstr: convert some instances of mp_uint_t to size_t
- objcomplex: fix typo in ternary expression
- asmxtensa.h: explicitly cast args to 32-bits so left-shift is legal
- map: change mp_uint_t to size_t where appropriate
- nlr: fix execstack builds for ARM
- objtype: add __delattr__/__setattr__ configured by MICROPY_PY_DELATTR_SETATTR
- emitbc: produce correct line number info for large bytecode chunks
- objtype: replace non-ASCII single-quote char with ASCII version
- modthread: use system-provided mutexs for _thread locks
- vm: add MICROPY_PY_THREAD_GIL_VM_DIVISOR option
- runtime: convert mp_uint_t to size_t where appropriate
- mpz: convert mp_uint_t to size_t where appropriate
- mpz: remove obsolete declaration of mpz_as_str_size
- mpz: change type of "base" args from mp_uint_t to unsigned int
- persistentcode: replace mp_uint_t with size_t where appropriate
- objtuple: convert mp_uint_t to size_t where appropriate
- objlist: convert mp_uint_t to size_t where appropriate
- objdict: convert mp_uint_t to size_t where appropriate
- objset: convert mp_uint_t to size_t where appropriate
- objstr: convert mp_uint_t to size_t (and use int) where appropriate
- objarray: convert mp_uint_t to size_t where appropriate
- objfun: convert mp_uint_t to size_t where appropriate
- objclosure: convert mp_uint_t to size_t where appropriate
- objexcept: convert mp_uint_t to size_t where appropriate
- objint: convert mp_uint_t to size_t where appropriate
- vm: convert mp_uint_t to size_t where appropriate
- add iter_buf to getiter type method
- allow bytecode/native to put iter_buf on stack for simple for loops
- make FOR_ITER opcode pop 1+4 slots from the stack when finished
- optimise storage of iterator so it takes only 4 slots on Py stack
- remove unused "use_stack" argument from for_iter_end emit function
- runtime: optimise case of identity iterator so it doesn't alloc RAM
- compile: optimise list/dict/set comprehensions to use stack iter
- de-optimise some uses of mp_getiter, so they don't use the C stack
- grammar: group no-compile grammar rules together to shrink tables
- lexer: don't generate string representation for period or ellipsis
- persistentcode: bump .mpy version due to change in bytecode
- lexer: simplify handling of indenting of very first token
- lexer: move check for keyword to name-tokenising block
- lexer: use strcmp to make keyword searching more efficient
- lexer: simplify handling of line-continuation error
- do adjacent str/bytes literal concatenation in lexer, not compiler
- lexer: convert mp_uint_t to size_t where appropriate
- grammar: remove unused rule
- objlist: for list slice assignment, allow RHS to be a tuple or list
- moduerrno: make uerrno.errorcode dict configurable
- moduerrno: make list of errno codes configurable
- parse: allow parser/compiler consts to be bignums
- create str/bytes objects in the parser, not the compiler
- parse: simplify handling of errors by raising them directly
- runtime: mp_raise_msg(): Accept NULL argument for message
- objarray: disallow slice-assignment to read-only memoryview
- map: fix bugs with deletion of elements from OrderedDict
- move locals/globals dicts to the thread-specific state
- nlr.h: mark nlr_jump_fail as NORETURN
- nlrxtensa: convert from assembler to C file with inline asm
- nlrx64: convert from assembler to C file with inline asm
- nlrx86: convert from assembler to C file with inline asm
- py.mk: force nlr files to be compiled with -Os
- modsys: use MP_SMALL_INT_MAX for sys.maxsize in case of LONGINT_IMPL_NONE
- runtime.c: remove optimization of '*a,=b', it caused a bug
- use mp_obj_get_array where sequence may be a tuple or a list
- nlrx86: add workaround for Zephyr
- nlrx64: fixes to support Mac OS
- objint_longlong: implement mp_obj_int_from_bytes_impl()
- allow lexer to raise exceptions during construction
- objint: allow to print long-long ints without using the heap
- emitnative: use assertions and mp_not_implemented correctly
- emitnative: remove obsolete commented out code
- mpprint: fix int formatting so "+" is printed for 0-valued integer
- mkrules.mk: remove special check for "-B" in qstr auto generation
- objstr: fix eager optimisation of str/bytes addition
- reduce size of mp_code_state_t structure
- provide mp_decode_uint_value to help optimise stack usage
- objstr: use better msg in bad implicit str/bytes conversion exception
- add micropython.schedule() function and associated runtime code
- vm: don't release the GIL if the scheduler is locked
- bc: provide better error message for an unexpected keyword argument
- use size_t as len argument and return type of mp_get_index
- sequence: convert mp_uint_t to size_t where appropriate
- define and use MP_OBJ_ITER_BUF_NSLOTS to get size of stack iter buf
- lexer: remove obsolete comment, since lexer can now raise exceptions
- modmath: allow trunc/ceil/floor to return a big int if necessary
- objint: handle special case of -0 when classifying fp as int
- modbuiltins: for round() builtin use nearbyint instead of round
- modbuiltins: allow round() to return a big int if necessary
- objtype: use size_t where appropriate, instead of mp_uint_t or uint
- objnamedtuple: use size_t where appropriate, instead of mp_uint_t
- use mp_locals/mp_globals accessor funcs instead of MP_STATE_CTX
- remove MP_STATE_CTX, use MP_STATE_THREAD instead (it's an alias)
- objarray: use mp_obj_str_get_str instead of mp_obj_str_get_data
- nlrx86: better check for Zephyr (requires 1.7)
- obj: change mp_uint_t to size_t for mp_obj_get_array_fixed_n len arg
- vm: fix VM opcode tracing to print correct stack pointer
- compile: when compiling super(), handle closed-over self variable
- objmap: convert mp_uint_t to size_t
- use mp_raise_TypeError/mp_raise_ValueError helpers where possible
- lexer: simplify and reduce code size for operator tokenising
- compile: simplify syntax-error messages for illegal assignments
- shorten a couple of error messages
- compile: provide terse error message for invalid dict/set literals
- convert mp_uint_t to size_t for tuple/list accessors
- change mp_uint_t to size_t for mp_obj_str_get_data len arg
- objzip: convert mp_uint_t to size_t
- obj.h: make sequence grow more efficient and support overlapping
- objstr: use MICROPY_FULL_CHECKS for range checking when constructing bytes
- add very simple but correct hashing for float and complex numbers
- objint: consolidate mp_obj_new_int_from_float to one implementation
- raise a ValueError if range() step is zero
- objtuple: add support for inplace add (same as normal add)
- make sure that static emg-exc-buffer is aligned to size of mp_obj_t
- runtime: when init'ing kbd intr exc, use tuple ptr instead of object
- objint: extract small int value directly because type is known
- objint: use unsigned arithmetic when formatting an integer
- obj: clean up and add comments describing mp_obj_type_t struct
- optimise types for common case where type has a single parent type
- objfloat: add implementation of high-quality float hashing
- nlrsetjmp: add check for failed NLR jump
- gc: execute finaliser code in a protected environment
- modmicropython: add micropython.kbd_intr() function
- reduce str/repr precision of float numbers when floats are 30-bit
- objtype: mp_obj_new_super doesn't need to be public, so inline it
- compile: don't do unnecessary check if parse node is a struct
- compile: extract parse-node kind at start of func for efficiency
- compile: add COMP_RETURN_IF_EXPR option to enable return-if-else opt
- compile: don't do unnecessary check if iter parse node is a struct
- compile: refactor handling of special super() call
- add LOAD_SUPER_METHOD bytecode to allow heap-free super meth calls
- mpz: strip trailing zeros from mpz value when set from bytes
- mpz: in mpn_sub, use existing function to remove trailing zeros
- cleanup use of global DEBUG preprocessor definition
- modio: implement uio.resource_stream(package, resource_path)
- objint: in int.from_bytes, only create big-int if really needed
- modio: resource_stream: Implement "package" param handling
- binary: handle storing big-ints to all arrays types
- lexer: simplify lexer startup by using dummy bytes and next_char()
- mkrules.mk: add dependency of .mpy files upon mpy-cross
- lexer: process CR earlier to allow newlines checks on chr1
- modsys: update conditionals for code referencing sys.stdout
- objstringio: fix StringIO reads at or beyond EOF
- sequence: fix boundary errors when slicing with a negative step
- objrange: fix slicing of range when step of slice is negative
- mkenv.mk: use $(TOP) instead of ".." to reference tools, mpy-cross
- vm: fix bug with stackless mode and unwinding of exceptions
- vm: fix bug with unwind jump popping the iterator from a for loop
- emitbc: fix bug with BC emitter computing Python stack size
- mkrules.mk: fix auto-qstr generation when "make -B" is used
- objstringio: catch mp_uint_t overflow of stream position in write()
- move BYTES_PER_WORD definition from ports to py/mpconfig.h

extmod:
- modframebuf: optimize fill_rect subroutine call
- modframebuf: clip pixels drawn by line method
- modframebuf: add GS4_HMSB format
- vfs_fat: rework so it can optionally use OO version of FatFS
- rename vfs_fat_file.h to vfs_fat.h
- add generic VFS sub-system
- vfs_fat: rework to support new generic VFS sub-system
- vfs: add ability for VFS sub-system to import using VfsFat
- modlwip: add socket.readinto() method
- vfs: expose mp_vfs_mount_t type
- vfs_fat: use SECSIZE macro to determine FatFs sector size
- machine_signal: implement "Signal" abstraction for machine module
- vfs_fat: update to use FF_DIR instead of DIR
- vfs: expose lookup_path_raw as mp_vfs_lookup_path
- vfs_fat: remove MICROPY_READER_FATFS component
- vfs_fat: remove MICROPY_FSUSERMOUNT_ADHOC config option
- remove MICROPY_FSUSERMOUNT and related files
- vfs_fat: remove MICROPY_FATFS_OO config option
- merge old fsusermount.h header into vfs.h and vfs_fat.h
- vfs_fat: remove unused fatfs_builtin_open function
- vfs_fat: remove unused function fat_vfs_listdir
- vfs_reader: fix use of NLR by popping context
- vfs_fat.c: use explicit include path for timeutils.h
- machine_pulse: make time_pulse_us() not throw exceptions
- machine_spi: remove EVENT_POLL_HOOK from soft-SPI transfer func
- machine_signal: implement Signal .on() and .off() methods
- vfs: allow to mount a block device, not just a VFS object
- vfs: raise OSError(EEXIST) on attempt to mkdir a mount point
- vfs: allow to stat the root directory
- modlwip: add my copyright
- modurandom: use mp_raise_ValueError()
- modutimeq: make scheduling fair (round-robin)
- modutimeq: add peektime() function (provisional)
- vfs_fat: remove obsolete and unused str/len members
- vfs_fat: allow to compile with MICROPY_VFS_FAT disabled
- vfs: rewrite path lookup algo to support relative paths from root
- modframebuf: add support for monochrome horizontal format
- utime_mphal: don't exit/enter the GIL in generic sleep functions
- modlwip: use mp_obj_str_get_str instead of mp_obj_str_get_data
- vfs_fat: fix calculation of total blocks in statvfs
- moduselect: update to use size_t for array accessor
- update for changes to mp_obj_str_get_data
- modframebuf: make monochrome bitmap formats start with MONO_
- machine_signal: support all Pin's arguments to the constructor
- machine_signal: rename "inverted" arg to "invert", it's shorter
- moductypes: fix bigint handling for 32-bit ports
- crypto-algorithms/sha256: remove non-standard memory.h header
- moduselect: convert to MP_ROM_QSTR and friends
- moduselect: refactor towards introduction of poll.ipoll()
- moduselect: implement ipoll() method for alloc-free polling
- modlwip: getaddrinfo: Allow to accept all 6 standard params
- modlwip: ioctl POLL: Fix handling of peer closed socket
- vfs: allow a VFS to be mounted at the root dir
- vfs: implement mp_vfs_ilistdir()
- vfs_fat: replace listdir() with implementation of ilistdir()
- vfs: use MP_S_IFDIR, MP_S_IFREG consts instead of magic numbers
- vfs_fat_misc: remove dot-dirs filter since FatFS already does it

lib:
- utils: remove old pyhelp helper, replaced with py/builtinhelp.c
- utils/pyexec: only print help prompt if HELP feature is enabled
- oofatfs: add OO version of FatFS library
- fatfs: remove old fatfs library component, it's replaced by oofatfs
- oofatfs/ffconf.h: allow to configure FS_EXFAT option
- oofatfs/ffconf.h: add MICROPY_FATFS_NORTC option
- utils/pyexec: allow to compile when the uPy compiler is disabled
- utils/pyexec: refactor to put lexer constructors all in one place
- memzip: make lexer constructor raise exception when file not found
- utils/pyexec: fix bug with pyexec_file not setting flag for source
- libm: add implementation of nearbyintf, from musl-1.1.16
- netutils: update for changes to mp_obj_str_get_data
- utils/pyexec: update event-driven REPL to match non-event REPL

drivers:
- fix some minor spelling mistakes
- display: add driver and test for uPy LCD160CR display
- memory: add SPI flash driver, written in C
- display/lcd160cr: use correct variable in set_power()
- display/lcd160cr: fix bugs with lcd.get_pixel()
- display/lcd160cr: fix bug with save_to_flash method
- display/lcd160cr: add check that JPEG size is less than 65536
- nrf24l01: update to work on newer ports, using machine, utime
- display/lcd160cr: fix get_line method and enhance screen_dump
- display/lcd160cr_test: allow test to take orientation parameter
- replace deprecated Pin.high()/low() methods with .__call__(1/0)

tools:
- tinytest-codegen.py: blacklist heapalloc_str.py test for qemu-arm
- upip: update to 1.1.5. Better and more user-friendly error handling
- add gen-cpydiff.py to generate docs differences
- gen-cpydiff.py: set the Python import path to find test modules
- gen-cpydiff.py: configurable CPython and micropython executables
- tinytest-codegen: update for recent test renaming ("intbig" suffix)
- pyboard: tighten up Pyboard object closure on errors
- pyboard: add "exec" and "execpty" pseudo-devices support
- pyboard: execpty: Use shell=False to workaround some curdir issues
- pyboard: processPtyToTerminal: Add workaround for PySerial bug
- pyboard: provide more details when expected reply not received
- mpy-tool: make work if run from another directory
- upip: upgrade to 1.1.6, supports commented lines in requirements.txt
- upip: upgrade to 1.2
- mpy-tool.py: use MP_ROM_xxx macros to support nanbox builds
- mpy_cross_all.py: helper tool to run mpy-cross on the entire project
- mpy-tool.py: fix regression with freezing floats in obj repr C

tests:
- add feature check for "const" keyword and skip related tests
- update test suite to be compatible with CPython 3.6
- improve stream.c test coverage
- import: improve builtinimport.c test coverage
- improve frozen import test coverage
- update tests, and add new ones, for recent generator tweaks
- io: improve test coverage of io.BufferedWriter
- basics: improve runtime.c test coverage
- extmod: improve test coverage of ure module
- float: add test for assigning to attribute of complex number
- extmod/framebuf1: add test for no-op fill_rect
- micropython/opt_level: add test for opt_level 3
- misc/non_compliant: add test for inability to assign func attrs
- basics: add test for assignment of attribute to bound method
- add test for int.from_bytes() for arbitrary-precision integer
- heapalloc_int_from_bytes: test that int.from_bytes() can work w/o alloc
- add test for builtin help function
- basics/builtin_help: add test for help('modules')
- make sure special tests can be skipped as well
- extmod/framebuf4: add tests for GS4_HMSB framebuf format
- extmod/framebuf1: fix test for framebuf invalid constructor
- extmod: add test for ure debug printing when compiling a regex
- heapalloc_str: test for alloc-free string operations
- extmod: update vfs_fat tests for new OO FatFs library
- extmod/vfs_fat: update tests to work with new VFS sub-system
- extmod/vfs_fat_ramdisk: make it work on pyboard
- run-tests: skip frozenset tests if set literal syntax is not available
- basics/zip: make skippable
- thread: make thread_exc2 runable on baremetal
- thread: fix stack size test so tests run reliably on baremetal
- heapalloc_bytesio: test for BytesIO with preallocates space
- basics/set_binop: add tests for inplace set operations
- float: add tests for zero to a negative power
- split tests for 2- and 3-arg pow()
- basics/string_format_modulo: add more tests for dict formatting
- pyb: adjust tests so they can run on PYB and PYBLITE
- misc: add test for line number printing with large bytecode chunk
- add option to not clear MICROPYPATH when running tests
- run-tests: allow to skip tests using async/await keywords
- comprehension1, containment: split set tests to separate files
- builtin_dir: the most expected thing in sys is exit, test for it
- basic/[a-f]*: make skippable
- dict_fromkeys: revert to use reversed() to run in native codegen mode
- extmod: make tests skippable
- thread: replace busy waiting loops with a loop that sleeps
- thread: add stress-test for creating many threads
- gen_yield_from_close: use range() instead of reversed()
- basic/: make various tests skippable
- cmdline: update tests to pass with latest changes to bytecode
- cmdline/cmd_showbc: update to work with recent changes
- micropython: add test for iterating with the heap locked
- micropython/heapalloc_iter: add tests for contains and unpack
- cmdline: update cmd_parsetree test for changes to grammar order
- cmdline/cmd_parsetree: update to work with changes to grammar
- basics/string_join: add more tests for string concatenation
- heapalloc_exc_raise.py: heap alloc test for raising/catching exc
- cpydiff: add initial set of tests for uPy-CPython differences
- cpydiff: add a test for storing iterable to a list slice
- micropython: add test for consts that are bignums
- extmod: add test for machine.Signal class
- basics: add further tests for OrderedDict
- run-tests: check for big int availability and skip related tests
- basic: split tests into working with small ints and not working
- float/complex1: split out intbig test
- float2int*: suffix with _intbig, don't run on any other int type
- string_format_modulo2: split off intbig test
- basics/string_join.py: add test case where argument is not iterable
- basics/unpack1.py: test if *a, = b copies b when b is a list
- micropython/: split off intbig tests
- uctypes_array_assign_native_le: split off intbig part
- basic: make various tests skippable
- float: make various tests skippable
- extmod: add very basic feature test for ussl module
- extmod: add websocket tests
- dict_fromkeys: split out skippable part
- micropython: make uio-using tests skippable
- micropython/heapalloc_traceback: fix backtrace line # after refactor
- micropython/opt_level: clarify the expected output for opt_level == 3
- feature_check/int_big: rework "big int" detection
- basics/fun_error: split out skippable test
- extmod: rename websocket test to websocket_basic
- misc/: make few tests skippable
- extmod: add a test for core VFS functionality, sans any filesystem
- extmod/vfs_basic: add more tests for basic VFS functionality
- extmod: improve re1.5/recursiveloop.c test coverage
- improve binary.c test coverage
- basics/struct_micropython: add test for 'S' typecode in ustruct
- run-tests: re-instate skipping of doubleprec test on pyboard
- extmod/vfs_basic: unmount all existing devices before doing test
- extmod: improve tinfgzip.c test coverage
- micropython/viper_error: add more tests to improve coverage
- basics/string_format2: adjust comment now that tests succeed
- basics: add test for string module formatting with int argument
- basics: move string-modulo-format int tests to dedicated file
- basics/bytes_add: add tests for optimised bytes addition
- micropython: add tests for micropython.schedule()
- heapalloc_str: test no-replacement case for str.replace()
- float: add tests for math funcs that return ints
- float: add tests for round() of inf, nan and large number
- basics: add test for super() when self is closed over
- basics: add tests for list and bytearray growing using themselves
- run-tests: be sure to close Pyboard object on completion
- vfs_fat_fileio.py is too big to be parsed in 16K heap, split in 2
- extmod/vfs_fat_fileio*: improve skippability
- float/byte*_construct: skip on missing array module
- micropython/heapalloc_iter: improve skippability
- run-tests: introduce generic "minimal" target
- float: add tests for hashing float and complex numbers
- run-tests: update names of tests that may need skipping
- basics: add tests for raising ValueError when range() gets 0 step
- basics: add test for tuple inplace add
- extmod/utimeq1: improve coverage of utimeq module
- run-tests: search feature checks wrt to main script location
- run-tests: don't post-process CRASH result in any way
- micropython: add test for micropython.kbd_intr()
- add tests for calling super and loading a method directly
- basics: add tests for int.from_bytes when src has trailing zeros
- cpydiff/core_arguments: fill in cause/workaround
- cpydiff/core_function_userattr: clarify, fill in cause and workaround
- cpydiff/core_import_prereg: fill in cause and workaround
- io/resource_stream: add test for uio.resource_stream()
- cpydiff/core_import_path: test showing difference in package.__path__
- cpydiff/core_import_split_ns_pkgs: test for split namespace packages
- cpydiff/core_function_unpacking: fill in workaround
- extmod: add more tests for VFS FAT
- extmod: add some more VFS tests
- micropython: add test for int.from_bytes with many zero bytes
- move super-as-local test from cpydiff to basic tests
- basics: update array test for big-int with lL typecodes
- basics: add memoryview test for big ints
- basics/lexer: add lexer tests for input starting with newlines
- extmod: make some vfs tests fully unmount FSs before running
- extmod/vfs: update tests to reflect new ilistdir() method
- basics/lexer: add line continuation tests for lexer
- extmod/vfs_fat: add test for ilistdir of a non-existent directory
- extmod/vfs_fat_more: make skippable is uos is not available
- io/bytesio_ext: test read() after seek() past end of BytesIO object
- basics/list_slice_3arg: add more tests for negative slicing
- basics/builtin_range: add tests for negative slicing of range
- basics: add more tests for unwind jumps from within a try-finally

mpy-cross:
- main: move lexer constructor to within NLR handler block
- fix compiler detection for including windows/fmode.c
- Makefile: override undefine any inherited variables
- Makefile: guard "override undefine" by test for make feature

bare-arm port:
- main: move lexer constructor to within NLR handler block
- Makefile: change C standard from gnu99 to c99

minimal port:
- update frozentest.mpy file for new .mpy version
- add ability and description to build without the compiler
- main: move lexer constructor to within NLR handler block
- Makefile: change C standard from gnu99 to c99
- main: make Cortex-M vector table constant

unix port:
- coverage: move coverage #if guard back to top of file
- enable builtin help function in coverage build
- enable MICROPY_PY_BUILTINS_HELP_MODULES in coverage build
- switch to OO version of FatFS library
- get minimal version compiling again
- change to use new generic VFS sub-system in coverage build
- fatfs_port: include new oofatfs header
- mpconfigport.h: remove obsolete MICROPY_FATFS_VOLUMES config
- modos: remove VfsFat from uos module, it's now in uos_vfs module
- make stack be non-executable
- fix freedos port build problems
- main: properly handle MICROPYPATH starting with ':'
- moduselect: implement ipoll() method with no-allocation policy
- modmachine: add Signal class to machine module
- remove remaining, obsolete traces of GNU readline support
- moduselect: properly implement ipoll object iteration
- main: refactor to put lexer constructors all in one place
- use mp_handle_pending() in time.sleep()
- coverage: enable scheduler and add tests for it
- use mp_obj_str_get_str instead of mp_obj_str_get_data
- convert mp_uint_t to size_t for use of mp_obj_list_get
- convert mp_uint_t to size_t in alloc.c
- enabled high-quality float hashing in coverage build
- remove obsolete MICROPY_FATFS macro
- main: ignore SIGPIPE signal, instead make EPIPE arrive
- main: don't allow to specify too small heap size
- main: implement -m option for packages
- Makefile: enable frozen bytecode modules dir
- move upip to frozen bytecode dir
- Makefile: don't add frozen bytecode to minimal build
- add ilistdir in uos module
- use core-provided KeyboardInterrupt exception object

windows port:
- .gitignore: ignore VC.db and VC.opendb files from VS2015
- make msvc project file support any version from VS2013 to VS2017
- bring mpconfigport.h up-to-date with unix port
- README: convert to Markdown
- README: fix some typos and grammar
- README: add a note about stack usage for msvc
- use core-provided KeyboardInterrupt exception object
- msvc: add machine/pin-related sources to build
- msvc: remove directory with generated files when cleaning
- msvc: do not define DEBUG for debug builds
- msvc: rebuild all qstrs when mpconfig headers are modified
- msvc: workaround parser bug in older MSBuild versions

qemu-arm port:
- don't compile tests in "REPL" mode
- mpconfigport.h: enable MICROPY_PY_BUILTINS_POW3 option
- enable machine module and associated tests
- add basic uos module with generic VFS capabilities
- move lexer constructors to within NLR handler block

stmhal port:
- support PortG on STM32L476 and STM32L486
- fix wrong usage of gcc -print-libgcc-file-name
- fix USB HID receive not receiving the first packet
- implement ioctl for USB HID read
- implement SNAK/CNAK mechanism for USB HID receive
- convert to use builtin help function
- enable help('modules') feature
- add default frozen-bytecode directory and link lcd160cr driver
- fix examples in openocd configs to include addresses
- add ability to have filesystem stored on external SPI flash
- boards/STM32L476DISC: use external SPI flash for filesystem
- mpconfigport.h: reorganise the config options into groups
- usbd_msc_storage: use storage functions instead of disk ones
- convert to use VFS sub-system and new ooFatFs component
- fix name of automatically created boot.py
- moduos: remove duplicated chdir
- use LED constants from PYBv4 onwards
- set the FatFs partition number when initialising VFS object
- fix stack pointer initialisation for F411 and F429 boards
- README: add paragraph about building mpy-cross
- on boot, mount all available partitions of the SD card
- main: put /sd directory before /flash in sys.path
- pin: add C-level pin ioctl method
- modmachine: add machine.Signal type
- main: guard init_sdcard_fs with MICROPY_HW_HAS_SDCARD
- pendsv: fill in comments about what the stack contains
- initial implementation of multithreading, currently disabled
- main: use _estack value to initialise stack extents
- fix build issue when MICROPY_PY_THREAD is disabled
- mpconfigport.h: enable MICROPY_PY_BUILTINS_POW3 option
- on HardFault, print stack pointer and do a stack dump
- add pyb.fault_debug() function, to control hard-fault behaviour
- use MICROPY_EVENT_POLL_HOOK instead of __WFI where appropriate
- add ability to skip booting from SD card via /flash/SKIPSD file
- Makefile: drop use of -mabi=aapcs-linux; link libgcc by default
- boards: for STM32F411DISC, change I2C pin according to datasheet
- implement a proper thread scheduler
- use generic interrupt char code
- main: remove unnecessary header includes
- use mp_hal_delay_ms instead of HAL_Delay
- rename sys_tick ticks/delay functions to corresp. mp_hal ones
- modpyb: use utime ticks ms/us functions instead of custom ones
- modnwcc3k: add include for mp_hal_delay_ms
- mphalport: get ticks_cpu() working on F7 MCUs
- main: allocate flash's VFS struct on the heap to trace root ptrs
- enable micropython.schedule()
- pendsv: disable interrupts during a thread switch
- irq: shift IRQ priorities of TIM and EXTINT to be above PENDSV
- pybthread: allow interrupts to work during lock/unlock of mutex
- systick: make mp_hal_delay_ms release the GIL when sleeping
- boards: fix alt-func config for PA5 of STM32F767
- board: fix existing and add more pin defs for NUCLEO_F767ZI
- spi: clean and/or invalidate D-cache before SPI DMA transfers
- hal: for F7 MCUs, expose DMA_CalcBaseAndBitshift function
- dma: fix reinitialisation of DMA on F7 MCUs, following F4
- update to use size_t for tuple/list accessors
- update for changes to mp_obj_str_get_data
- spi: increase SPI transfer timeout, proportional to num bytes
- support SDMMC alternate functions in pin generation
- sdcard: add support for SDMMC2 on F7 MCUs
- boards: update F76x alternate function table to add SDMMC2
- boards/STM32F769DISC: get SD card working by using SDMMC2
- boards/STM32F769DISC: fix user switch pin, and document stlink
- boards: remove F769 alt function table, it's same as for F767
- dma: don't include SDMMC2 struct if SDMMC2 is not available
- move L4/F7 I2C timing constants from mpconfigboard.h to i2c.c
- i2c: clean the cache so that I2C DMA works on F7 MCUs
- usbd_cdc_interface: increase in-endpoint timeout to 500ms
- usbd_cdc_interface: change CDC RX to use a circular buffer
- enable parsing of all Pin constructor args by machine.Signal
- timer: clear interrupt flag before setting callback
- convert all module and method tables to use MP_ROM macros
- modmachine: add machine.UART class, linking to pyb.UART
- modmachine: remove TODO comment that is now implemented
- add machine.Pin on/off methods
- add ilistdir in uos module

cc3200 port:
- convert to use builtin help function
- add implementations of mp_import_stat and builtin_open
- modusocket: remove deprecated socket.error
- convert to use new VFS sub-system and new ooFatFs library
- refactor "ticks" functions to use common extmod implementation
- move stoupper to ftp.c and define in terms of unichar_toupper
- use simplelink API instead of emulated BSD API
- remove util/std.h, can just use stdio.h instead
- mods/modwlan: remove unused header includes; simplify others
- mods/modwlan: make multi-threaded a proper compile-time option
- mods/modwlan: allow antenna diversity to be fully compiled out
- mods/modwlan: add int casts to silence compiler warnings
- remove remaining references to std.h
- move wlan socket glue functions from modwlan to modusocket
- convert to using uPy internal errno numbers
- when raising OSError's use MP_Exxx as arg instead of a string
- enable uerrno module with short, custom list of error codes
- mods/modusocket: init vars to 0 to silence compiler warnings
- remove socket.timeout class, use OSError(ETIMEDOUT) instead
- moduos: remove uos.sep, as it's strictly optional
- mptask: allocate flash VFS struct on the heap to trace root ptrs
- mods/modutime: use generic sleep_ms and sleep_us implementations
- update to use size_t for tuple/list accessors
- update for changes to mp_obj_str_get_data
- mods/pybi2c: raise OSError if readfrom_mem fails to write addr
- modmachine: return frequency value directly, like other ports
- pybuart: make parity specifications consistent with HW API
- mods/pybi2c: make machine.I2C constructor/init conform to HW API
- mods/pybi2c: make readfnom_mem_into/writeto_mem return None
- mods/pybpin: remove toggle() method

teensy port:
- convert to use builtin help function
- main: remove unnecessary header includes
- lexerfrozen: make mp_lexer_new_from_file raise an exception

esp8266 port:
- convert to use builtin help function
- factor out common linker code to esp8266_common.ld
- switch to use OO version of FatFs library
- change to use new generic VFS sub-system
- fatfs_port: include new oofatfs header
- machine_pin: implement pin ioctl protocol
- modmachine: add Signal class
- mpconfigport.h: remove obsolete MICROPY_FATFS_VOLUMES config
- uart: add support for polling uart device
- moduos: populate release field of uname in case it was GC'd
- mpconfigport.h: enable help('modules') feature
- update lexer constructors so they can raise exceptions
- only execute main.py if in friendly REPL mode
- enable micropython.schedule() with locking in pin callback
- change machine.Timer callback to soft callback
- machine_pin: add "hard" parameter to pin.irq, soft by default
- machine_pin: make pin.irq arguments positional
- machine_pin: fix memset size for zeroing of pin_irq_is_hard
- machine_pin: fix pin.irq() to work when all args are keywords
- modesp: use mp_obj_str_get_str instead of mp_obj_str_get_data
- modesp: remove long-obsolete and unused espconn bindings
- update to use size_t for tuple/list accessors
- update for changes to mp_obj_str_get_data
- remove unused entry in port root pointers
- README: replace reference of alpha status to beta status
- README: add notice about 512K version
- change default settings to mount flash at root dir
- esp8266.ld, esp8266_ota.ld: grow main firmware size by 32KB
- modesp: flash_user_start: Use value from linker script
- modules/flashbdev: reserve one sector for native code storage
- scripts: move drivers/modules to modules/ (frozen bytecode)
- scripts: move initsetup & port_diag tools to modules/
- ets_alt_task.c: prevent spurious large increment of ticks_ms()
- modnetwork: in connect, fix potential buffer overflows
- machine_uart: add uart.any() method
- modules: mount filesystem at root when creating for first time
- mpconfigport.h: remove duplicate link to lwip module
- rename machine.Pin high/low methods to on/off
- add ilistdir in uos module

zephyr port:
- help: update n_args param type to size_t
- remove deprecated .mdef file
- add separate Zephyr config for "minimal" build
- enable SLIP networking for the default build
- convert to use builtin help function
- make sure that correct Zephyr config is used for "minimal" build
- allow to have per-board Zephyr config fragments
- prj_frdm_k64f.conf: add, enable Ethernet support
- Makefile.zephyr: support and default to networked (SLIP) QEMU
- README: describe many gotchas of networked builds
- enable IPv6 networking in addition to IPv4
- add qemu_cortex_m3 config fragment
- main: don't unconditionally dump stats on each GC
- README: network startup issues with frdm_k64f resolved
- modzephyr: add a module for Zephyr-specific things
- modzephyr: fix typo in identifier
- make sure that generated prj.conf is updated only on content changes
- move "minimal" configuration building to a separate wrapper script
- main: nlr_jump_fail: Fix noreturn warning
- main: remove unused __fatal_error()
- main: move lexer constructor to within NLR handler block
- zephyr_getchar: use native k_sem instead of legacy nano_sem
- prj_base.conf: disable legacy kernel compatibility
- prj_base.conf: enable TCP (and UDP explicitly)
- Makefile: rework to use modern, official build integration
- Makefile: add workaround (fix?) for broken builds for DTS targets
- fix NLR segfault in minimal build
- modusocket: initial version of usocket module for Zephyr
- integrate modusocket into build
- modusocket: implement bind() and connect()
- modusocket: implement send()
- modusocket: implement recv() for UDP sockets
- modusocket: implement recv() for TCP sockets
- prj_base.conf: add config for net_buf logging
- modusocket: be sure to use MP_OBJ_FROM_PTR
- modusocket: factor out socket_new() function
- zephyr_getchar: explicitly yield to other threads on char availability
- Makefile: add "test" target, runs testsuite in QEMU
- modusocket: factor out "extended k_fifo API"
- modusocket: implement listen()
- modusocket: socket_bind: Don't set recv callback on STREAM sockets
- modusocket: implement accept()
- mpconfigport.h: fix build if usocket module is disabled
- modmachine: add Signal class
- machine_pin: implement pin protocol for machine.Signal support
- modusocket: call net_nbuf_print_frags() in recv callback if DEBUG > 1
- modusocket: strip packet header right in the receive callback
- modmachine: implement machine.reset()
- main: configure IPv4 netmask and gateway to allow Internet access
- add 96b_carbon configuration
- modusocket: refactor send() into stream write() method
- modusocket: enable stream write() method
- modusocket: refactor recv() into stream read() method
- modusocket: add read/readline/readinto stream methods
- modusocket: sock_read: Check socket status only at the start of packet
- modusocket: add dummy makefile() implementation
- Makefile: add debugserver Zephyr target
- mpconfigport.h: enable line number information for scripts
- main: remove superfluous include
- modusocket: add dummy setsockopt() implementation
- modusocket: add SOL_SOCKET and SO_REUSEADDR constants
- prj_qemu_x86.conf: bump RAM size to 320K
- README: update to require Zephyr 1.8
- modusocket: wrap pkt_get_info() call
- modusocket: update for net_pkt refactor
- modusocket: switch to net_pkt_append() returning length
- modusocket: if there're no packets in recv_q, cancel waiter
- modusocket: implement getaddrinfo()
- modusocket: first step to switch to alternative FIFO processing
- modusocket: get rid of cur_pkt object member
- main: check default netif before applying operations to it
- modusocket: getaddrinfo: Use RAISE_ERRNO for proper error decoding
- modusocket: getaddrinfo: Raise OSError on resolution timeout, etc
- modusocket: use DEBUG_PRINT macro name as other modules do
- rename machine.Pin high/low methods to on/off
- don't send more than MTU allows
- modusocket: handle a case when recv_q is empty when EOF is signaled

pic16bit port:
- main: make nlr_jump_fail never return
- main: make mp_lexer_new_from_file raise an exception

README:
- explicitly mention "await" support, and formatting for keywords
- add link to docs.micropython.org
- describe extmod/ dir
- change Travis & Coveralls badges to not use link references

travis:
- unconditionally run coveralls analysis, even if others failed
- change an stmhal rule to build PYBV11 instead of default PYBV10

gitattributes:
- add .mpy files to list of binary files
- remove obsolete lines

docs:
- fix some minor spelling mistakes
- add documentation for lcd160cr module
- pyboard/tutorial: add tutorial for LCD160CR
- library/lcd160cr: fix set_brightness range, should be 0..31
- machine.Timer: move WiPy adhoc parts to its documentation
- machine: add explicit note on machine module level and scope
- usocket: clarify exceptions used
- usocket: elaborate "Constants" section
- usocket: clarify description of various methods
- usocket: dedent Methods section
- uio: describe differences between uPy an CPy stream hierarchy
- conf.py: add myself as a copyright holder on the docs
- uio: typo fixes/lexical improvements
- pyboard/tutorial/lcd160cr_skin: fix typo, get_touched->get_touch
- for LCD160CR driver and tutorial, add link to positioning image
- esp8266/tutorial: specify the baudrate in picocom example command
- add M-logo as favicon
- library/pyb.Pin: minor typo fix, B6 should be A0
- library/machine: make separate TOC for WiPy vs non-WiPy
- uos: remove mention of uos.sep
- library/lcd160cr: mention the valid values for set_power() method
- modify Makefile and indexes to generate cPy-differences pages
- uhashlib: provide port-neutral description
- Makefile: define and use PYTHON as the interpreter for CPYDIFF
- machine: fix formatting of Constants section
- library/lcd160cr: add note about supported JPEG format/encodings
- library: add framebuf documentation
- library/lcd160cr: add link to framebuf page
- esp8266/tutorial: update since esptool 1.3 added Python 3 support
- library/framebuf: fix typo in bit-width for MVLSB description
- library/machine.I2C: fix scan() doc to match implementation
- library/btree: add btree module docs
- utime: de-conditionalize description of sleep_ms() and friends
- uos: de-conditionalize statvfs() description
- machine.SPI: remove outdated wipy chunk
- machine.Pin: move wipy-specific details to its own docs
- machine.Pin: move wipy-specific methods to its docs
- esp8266/general: start explicit "Known Issues", mentioned RTC inaccuracy
- library/builtins: int: Add notice on byteorder param for to/from_bytes
- library/machine.UART: remove some conditionals
- utime: deconditionalize description of sleep()
- usocket: deconditionalize
- uhashlib: deconditionalize
- esp8266/tutorial/intro: reword section on flash size requirement
- library/micropython: deconditionalize
- library/uos: urandom: Generalize description
- library/ussl: deconditionalize, wipy notes moved to its documentation
- machine.UART: deconditionalize normal methods
- machine: move machine.main() misnomer to wipy's known issues
- library/machine: typo fix in machine_callbacks section
- library/machine.UART: remove pyboard-specific section
- wipy/quickref: update reference for change to I2C API
- wipy/general: add section about specifics of I2C implementation
- library/machine.I2C: deconditionalise all methods
- library/machine.*: add cross-reference label to individual classes
- esp8266/quickref: add links from quickref page to machine classes
- library/machine.I2C: remove WiPy-specific return values
- library/machine.SPI: fix formatting of bullet list to stop warning
- library/uos: add description of uos.ilistdir() function
- machine.Pin: there's no toggle() method in MicroPython hardware API
- machine.Signal: add initial draft description of Signal class
- library/index: add important summary of the intro section as warning
- change single occurrence of "Micropython" to "MicroPython"
- library/micropython: document the newer micropython functions
- library/machine.UART: update and improve uart.any() docs
- library/machine.Pin: remove .id() method and .board class attr

examples:
- hwapi: use Signal for inverted LED on ESP-12
- hwapi: consistently use Signal class to define LEDs
- button_reaction: update for time_pulse_us() no longer raising exc
- hwapi: add hwconfig_pyboard.py for pyboard
- hwapi: be sure to import Signal when it's used
- hwapi/soft_pwm: use Signal on()/off() methods
- embedding/README: convert to markdown, grammar and clarity fixes
- embedding: place lexer constructor within NLR handler block
- hwapi: add config for Zephyr port of 96Boards Carbon
- hwapi/hwconfig*: use inline Signal() args where possible
- hwapi/soft_pwm2_uasyncio: update for call_later_ms()

120 files changed, 1095 insertions, 278 deletions

diff --git a/tests/basics/array_q.py b/tests/basics/array_intbig.py
index 2975cd3851..4a3b2a0d42 100644
--- a/tests/basics/array_q.py
+++ b/tests/basics/array_intbig.py
@@ -1,4 +1,4 @@
-# test array('q') and array('Q')
+# test array types QqLl that require big-ints
 
 try:
     from array import array
@@ -7,6 +7,9 @@ except ImportError:
     print("SKIP")
     sys.exit()
 
+print(array('L', [0, 2**32-1]))
+print(array('l', [-2**31, 0, 2**31-1]))
+
 print(array('q'))
 print(array('Q'))
 
diff --git a/tests/basics/array_micropython.py b/tests/basics/array_micropython.py
index 8e904bdfea..0c1df0923b 100644
--- a/tests/basics/array_micropython.py
+++ b/tests/basics/array_micropython.py
@@ -1,5 +1,10 @@
 # test MicroPython-specific features of array.array
-import array
+try:
+    import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 # arrays of objects
 a = array.array('O')
diff --git a/tests/basics/attrtuple1.py b/tests/basics/attrtuple1.py
index c4daaaf257..597bfc2a32 100644
--- a/tests/basics/attrtuple1.py
+++ b/tests/basics/attrtuple1.py
@@ -4,6 +4,15 @@
 import sys
 t = sys.implementation
 
+# It can be just a normal tuple on small ports
+try:
+    t.name
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+
 # test printing of attrtuple
 print(str(t).find("version=") > 0)
 
diff --git a/tests/basics/boundmeth1.py b/tests/basics/boundmeth1.py
index a728872755..f483ba406d 100644
--- a/tests/basics/boundmeth1.py
+++ b/tests/basics/boundmeth1.py
@@ -22,3 +22,9 @@ print(m(1))
 # bound method with lots of extra args
 m = A().h
 print(m(1, 2, 3, 4, 5, 6))
+
+# can't assign attributes to a bound method
+try:
+    A().f.x = 1
+except AttributeError:
+    print('AttributeError')
diff --git a/tests/basics/builtin_abs.py b/tests/basics/builtin_abs.py
index 788bc450f8..142344e226 100644
--- a/tests/basics/builtin_abs.py
+++ b/tests/basics/builtin_abs.py
@@ -4,11 +4,3 @@ print(abs(False))
 print(abs(True))
 print(abs(1))
 print(abs(-1))
-
-# bignum
-print(abs(123456789012345678901234567890))
-print(abs(-123456789012345678901234567890))
-
-# edge cases for 32 and 64 bit archs (small int overflow when negating)
-print(abs(-0x3fffffff - 1))
-print(abs(-0x3fffffffffffffff - 1))
diff --git a/tests/basics/builtin_abs_intbig.py b/tests/basics/builtin_abs_intbig.py
new file mode 100644
index 0000000000..3dd5ea89fa
--- /dev/null
+++ b/tests/basics/builtin_abs_intbig.py
@@ -0,0 +1,9 @@
+# test builtin abs
+
+# bignum
+print(abs(123456789012345678901234567890))
+print(abs(-123456789012345678901234567890))
+
+# edge cases for 32 and 64 bit archs (small int overflow when negating)
+print(abs(-0x3fffffff - 1))
+print(abs(-0x3fffffffffffffff - 1))
diff --git a/tests/basics/builtin_bin.py b/tests/basics/builtin_bin.py
index f6b6079de5..85af406ce3 100644
--- a/tests/basics/builtin_bin.py
+++ b/tests/basics/builtin_bin.py
@@ -8,5 +8,4 @@ print(bin(-15))
 print(bin(12345))
 print(bin(0b10101))
 
-print(bin(12345678901234567890))
 print(bin(0b10101010101010101010))
diff --git a/tests/basics/builtin_bin_intbig.py b/tests/basics/builtin_bin_intbig.py
new file mode 100644
index 0000000000..345e1f6873
--- /dev/null
+++ b/tests/basics/builtin_bin_intbig.py
@@ -0,0 +1,3 @@
+# test builtin bin function
+
+print(bin(12345678901234567890))
diff --git a/tests/basics/builtin_delattr.py b/tests/basics/builtin_delattr.py
index 3743df227c..9b38837e44 100644
--- a/tests/basics/builtin_delattr.py
+++ b/tests/basics/builtin_delattr.py
@@ -1,4 +1,10 @@
 # test builtin delattr
+try:
+    delattr
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 class A: pass
 a = A()
diff --git a/tests/basics/builtin_dir.py b/tests/basics/builtin_dir.py
index 843467e783..16e7e669e4 100644
--- a/tests/basics/builtin_dir.py
+++ b/tests/basics/builtin_dir.py
@@ -5,7 +5,7 @@ print('__name__' in dir())
 
 # dir of module
 import sys
-print('platform' in dir(sys))
+print('exit' in dir(sys))
 
 # dir of type
 print('append' in dir(list))
diff --git a/tests/basics/builtin_divmod.py b/tests/basics/builtin_divmod.py
index c3b8658197..26b3ae3824 100644
--- a/tests/basics/builtin_divmod.py
+++ b/tests/basics/builtin_divmod.py
@@ -10,18 +10,6 @@ except ZeroDivisionError:
     print("ZeroDivisionError")
 
 try:
-    divmod(1 << 65, 0)
-except ZeroDivisionError:
-    print("ZeroDivisionError")
-
-try:
     divmod('a', 'b')
 except TypeError:
     print("TypeError")
-
-# bignum
-l = (1 << 65) + 123
-print(divmod(3, l))
-print(divmod(l, 5))
-print(divmod(l + 3, l))
-print(divmod(l * 20, l + 2))
diff --git a/tests/basics/builtin_divmod_intbig.py b/tests/basics/builtin_divmod_intbig.py
new file mode 100644
index 0000000000..758e834151
--- /dev/null
+++ b/tests/basics/builtin_divmod_intbig.py
@@ -0,0 +1,13 @@
+# test builtin divmod
+
+try:
+    divmod(1 << 65, 0)
+except ZeroDivisionError:
+    print("ZeroDivisionError")
+
+# bignum
+l = (1 << 65) + 123
+print(divmod(3, l))
+print(divmod(l, 5))
+print(divmod(l + 3, l))
+print(divmod(l * 20, l + 2))
diff --git a/tests/basics/builtin_hash.py b/tests/basics/builtin_hash.py
index ffea08e575..704895fbb6 100644
--- a/tests/basics/builtin_hash.py
+++ b/tests/basics/builtin_hash.py
@@ -4,8 +4,6 @@ print(hash(False))
 print(hash(True))
 print({():1}) # hash tuple
 print({(1,):1}) # hash non-empty tuple
-print({1 << 66:1}) # hash big int
-print({-(1 << 66):2}) # hash negative big int
 print(hash in {hash:1}) # hash function
 
 try:
@@ -50,9 +48,3 @@ class E:
     def __hash__(self):
         return True
 print(hash(E()))
-
-# __hash__ returning a large number should be truncated
-class F:
-    def __hash__(self):
-        return 1 << 70 | 1
-print(hash(F()) != 0)
diff --git a/tests/basics/builtin_hash_intbig.py b/tests/basics/builtin_hash_intbig.py
new file mode 100644
index 0000000000..0092c0f3ad
--- /dev/null
+++ b/tests/basics/builtin_hash_intbig.py
@@ -0,0 +1,10 @@
+# test builtin hash function
+
+print({1 << 66:1}) # hash big int
+print({-(1 << 66):2}) # hash negative big int
+
+# __hash__ returning a large number should be truncated
+class F:
+    def __hash__(self):
+        return 1 << 70 | 1
+print(hash(F()) != 0)
diff --git a/tests/basics/builtin_help.py b/tests/basics/builtin_help.py
new file mode 100644
index 0000000000..d554f308d9
--- /dev/null
+++ b/tests/basics/builtin_help.py
@@ -0,0 +1,18 @@
+# test builtin help function
+
+try:
+    help
+except NameError:
+    print("SKIP")
+    import sys
+    sys.exit()
+
+help() # no args
+help(help) # help for a function
+help(int) # help for a class
+help(1) # help for an instance
+import micropython
+help(micropython) # help for a module
+help('modules') # list available modules
+
+print('done') # so last bit of output is predictable
diff --git a/tests/basics/builtin_help.py.exp b/tests/basics/builtin_help.py.exp
new file mode 100644
index 0000000000..ed8a7d74b8
--- /dev/null
+++ b/tests/basics/builtin_help.py.exp
@@ -0,0 +1,14 @@
+########
+object <function> is of type function
+object <class 'int'> is of type type
+  from_bytes -- <classmethod>
+  to_bytes -- <function>
+object 1 is of type int
+  from_bytes -- <classmethod>
+  to_bytes -- <function>
+object <module 'micropython'> is of type module
+  __name__ -- micropython
+  const -- <function>
+  opt_level -- <function>
+########
+done
diff --git a/tests/basics/builtin_hex.py b/tests/basics/builtin_hex.py
index 7d1c98a7a9..95d74257ec 100644
--- a/tests/basics/builtin_hex.py
+++ b/tests/basics/builtin_hex.py
@@ -7,6 +7,3 @@ print(hex(-15))
 
 print(hex(12345))
 print(hex(0x12345))
-
-print(hex(12345678901234567890))
-print(hex(0x12345678901234567890))
diff --git a/tests/basics/builtin_hex_intbig.py b/tests/basics/builtin_hex_intbig.py
new file mode 100644
index 0000000000..7049ca3f55
--- /dev/null
+++ b/tests/basics/builtin_hex_intbig.py
@@ -0,0 +1,4 @@
+# test builtin hex function
+
+print(hex(12345678901234567890))
+print(hex(0x12345678901234567890))
diff --git a/tests/basics/builtin_minmax.py b/tests/basics/builtin_minmax.py
index d395d4421b..a925b3fe92 100644
--- a/tests/basics/builtin_minmax.py
+++ b/tests/basics/builtin_minmax.py
@@ -1,4 +1,11 @@
 # test builtin min and max functions
+try:
+    min
+    max
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 print(min(0,1))
 print(min(1,0))
diff --git a/tests/basics/builtin_oct.py b/tests/basics/builtin_oct.py
index d8ba8e4346..6dc48a6fae 100644
--- a/tests/basics/builtin_oct.py
+++ b/tests/basics/builtin_oct.py
@@ -7,6 +7,3 @@ print(oct(-15))
 
 print(oct(12345))
 print(oct(0o12345))
-
-print(oct(12345678901234567890))
-print(oct(0o12345670123456701234))
diff --git a/tests/basics/builtin_oct_intbig.py b/tests/basics/builtin_oct_intbig.py
new file mode 100644
index 0000000000..4dc28ab46f
--- /dev/null
+++ b/tests/basics/builtin_oct_intbig.py
@@ -0,0 +1,4 @@
+# test builtin oct function
+
+print(oct(12345678901234567890))
+print(oct(0o12345670123456701234))
diff --git a/tests/basics/builtin_override.py b/tests/basics/builtin_override.py
index e245985ad9..f3632e59a7 100644
--- a/tests/basics/builtin_override.py
+++ b/tests/basics/builtin_override.py
@@ -3,7 +3,13 @@
 import builtins
 
 # override generic builtin
-builtins.abs = lambda x: x + 1
+try:
+    builtins.abs = lambda x: x + 1
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
 print(abs(1))
 
 # __build_class__ is handled in a special way
diff --git a/tests/basics/builtin_pow.py b/tests/basics/builtin_pow.py
index a19ab8c843..5012a76bee 100644
--- a/tests/basics/builtin_pow.py
+++ b/tests/basics/builtin_pow.py
@@ -1,11 +1,7 @@
 # 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/builtin_pow3.py b/tests/basics/builtin_pow3.py
new file mode 100644
index 0000000000..dec7253bbd
--- /dev/null
+++ b/tests/basics/builtin_pow3.py
@@ -0,0 +1,25 @@
+# test builtin pow() with integral values
+# 3 arg version
+
+try:
+    print(pow(3, 4, 7))
+except NotImplementedError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# 3 arg pow is defined to only work on integers
+try:
+    print(pow("x", 5, 6))
+except TypeError:
+    print("TypeError expected")
+
+try:
+    print(pow(4, "y", 6))
+except TypeError:
+    print("TypeError expected")
+
+try:
+    print(pow(4, 5, "z"))
+except TypeError:
+    print("TypeError expected")
diff --git a/tests/basics/builtin_pow3_intbig.py b/tests/basics/builtin_pow3_intbig.py
new file mode 100644
index 0000000000..9f482cbde7
--- /dev/null
+++ b/tests/basics/builtin_pow3_intbig.py
@@ -0,0 +1,23 @@
+# test builtin pow() with integral values
+# 3 arg version
+
+try:
+    print(pow(3, 4, 7))
+except NotImplementedError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+print(pow(555557, 1000002, 1000003))
+
+# Tests for 3 arg pow with large values
+
+# This value happens to be prime
+x = 0xd48a1e2a099b1395895527112937a391d02d4a208bce5d74b281cf35a57362502726f79a632f063a83c0eba66196712d963aa7279ab8a504110a668c0fc38a7983c51e6ee7a85cae87097686ccdc359ee4bbf2c583bce524e3f7836bded1c771a4efcb25c09460a862fc98e18f7303df46aaeb34da46b0c4d61d5cd78350f3edb60e6bc4befa712a849
+y = 0x3accf60bb1a5365e4250d1588eb0fe6cd81ad495e9063f90880229f2a625e98c59387238670936afb2cafc5b79448e4414d6cd5e9901aa845aa122db58ddd7b9f2b17414600a18c47494ed1f3d49d005a5
+
+print(hex(pow(2, 200, x))) # Should not overflow, just 1 << 200
+print(hex(pow(2, x-1, x))) # Should be 1, since x is prime
+print(hex(pow(y, x-1, x))) # Should be 1, since x is prime
+print(hex(pow(y, y-1, x))) # Should be a 'big value'
+print(hex(pow(y, y-1, y))) # Should be a 'big value'
diff --git a/tests/basics/builtin_property.py b/tests/basics/builtin_property.py
index 403abd62f4..ff4ff073c4 100644
--- a/tests/basics/builtin_property.py
+++ b/tests/basics/builtin_property.py
@@ -1,4 +1,10 @@
 # test builtin property
+try:
+    property
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 # create a property object explicitly
 property()
diff --git a/tests/basics/builtin_range.py b/tests/basics/builtin_range.py
index 59fc0344a4..0e2fabd82e 100644
--- a/tests/basics/builtin_range.py
+++ b/tests/basics/builtin_range.py
@@ -33,11 +33,16 @@ print(range(1, 4)[0:])
 print(range(1, 4)[1:])
 print(range(1, 4)[:-1])
 print(range(7, -2, -4)[:])
+print(range(1, 100, 5)[5:15:3])
+print(range(1, 100, 5)[15:5:-3])
+print(range(100, 1, -5)[5:15:3])
+print(range(100, 1, -5)[15:5:-3])
 
-# attrs
-print(range(1, 2, 3).start)
-print(range(1, 2, 3).stop)
-print(range(1, 2, 3).step)
+# zero step
+try:
+    range(1, 2, 0)
+except ValueError:
+    print("ValueError")
 
 # bad unary op
 try:
@@ -50,9 +55,3 @@ try:
     range(1)[0] = 1
 except TypeError:
     print("TypeError")
-
-# bad attr (can't store)
-try:
-    range(4).start = 0
-except AttributeError:
-    print('AttributeError')
diff --git a/tests/basics/builtin_range_attrs.py b/tests/basics/builtin_range_attrs.py
new file mode 100644
index 0000000000..9327c802a5
--- /dev/null
+++ b/tests/basics/builtin_range_attrs.py
@@ -0,0 +1,19 @@
+# test attributes of builtin range type
+
+try:
+    range(0).start
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# attrs
+print(range(1, 2, 3).start)
+print(range(1, 2, 3).stop)
+print(range(1, 2, 3).step)
+
+# bad attr (can't store)
+try:
+    range(4).start = 0
+except AttributeError:
+    print('AttributeError')
diff --git a/tests/basics/builtin_reversed.py b/tests/basics/builtin_reversed.py
index f129a4f5d5..59e9c78219 100644
--- a/tests/basics/builtin_reversed.py
+++ b/tests/basics/builtin_reversed.py
@@ -1,4 +1,10 @@
 # test the builtin reverse() function
+try:
+    reversed
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 # list
 print(list(reversed([])))
diff --git a/tests/basics/builtin_sorted.py b/tests/basics/builtin_sorted.py
index a4f71a15eb..68855b61ba 100644
--- a/tests/basics/builtin_sorted.py
+++ b/tests/basics/builtin_sorted.py
@@ -1,4 +1,11 @@
 # test builtin sorted
+try:
+    sorted
+    set
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 print(sorted(set(range(100))))
 print(sorted(set(range(100)), key=lambda x: x + 100*(x % 2)))
diff --git a/tests/basics/bytearray_construct.py b/tests/basics/bytearray_construct.py
index 1c45f6fcf5..9c8f3adaaa 100644
--- a/tests/basics/bytearray_construct.py
+++ b/tests/basics/bytearray_construct.py
@@ -1,12 +1,6 @@
 # test construction of bytearray from different objects
 
-from array import array
-
 # bytes, tuple, list
 print(bytearray(b'123'))
 print(bytearray((1, 2)))
 print(bytearray([1, 2]))
-
-# arrays
-print(bytearray(array('b', [1, 2])))
-print(bytearray(array('h', [0x101, 0x202])))
diff --git a/tests/basics/bytearray_construct_array.py b/tests/basics/bytearray_construct_array.py
new file mode 100644
index 0000000000..6d45cafda3
--- /dev/null
+++ b/tests/basics/bytearray_construct_array.py
@@ -0,0 +1,11 @@
+# test construction of bytearray from different objects
+try:
+    from array import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# arrays
+print(bytearray(array('b', [1, 2])))
+print(bytearray(array('h', [0x101, 0x202])))
diff --git a/tests/basics/bytearray_construct_endian.py b/tests/basics/bytearray_construct_endian.py
index dbd635c0c9..f68f9b89d1 100644
--- a/tests/basics/bytearray_construct_endian.py
+++ b/tests/basics/bytearray_construct_endian.py
@@ -1,6 +1,10 @@
 # test construction of bytearray from different objects
-
-from array import array
+try:
+    from array import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 # arrays
 print(bytearray(array('h', [1, 2])))
diff --git a/tests/basics/bytearray_longint.py b/tests/basics/bytearray_intbig.py
index 334eabe122..334eabe122 100644
--- a/tests/basics/bytearray_longint.py
+++ b/tests/basics/bytearray_intbig.py
diff --git a/tests/basics/bytearray_slice_assign.py b/tests/basics/bytearray_slice_assign.py
index 510e784da7..c4b5c43e33 100644
--- a/tests/basics/bytearray_slice_assign.py
+++ b/tests/basics/bytearray_slice_assign.py
@@ -51,6 +51,11 @@ b = bytearray(10)
 b[:-1] = bytearray(500)
 print(len(b), b[0], b[-1])
 
+# extension with self on RHS
+b = bytearray(x)
+b[4:] = b
+print(b)
+
 # Assignment of bytes to array slice
 b = bytearray(2)
 b[1:1] = b"12345"
diff --git a/tests/basics/bytes_add.py b/tests/basics/bytes_add.py
index 7a887db231..ebccf0662d 100644
--- a/tests/basics/bytes_add.py
+++ b/tests/basics/bytes_add.py
@@ -3,9 +3,6 @@
 print(b"123" + b"456")
 print(b"123" + bytearray(2))
 
-import array
-
-# should be byteorder-neutral
-print(b"123" + array.array('h', [0x1515]))
-
-print(b"\x01\x02" + array.array('b', [1, 2]))
+print(b"123" + b"") # RHS is empty, can be optimised
+print(b"" + b"123") # LHS is empty, can be optimised
+print(b"" + bytearray(1)) # LHS is empty but can't be optimised
diff --git a/tests/basics/bytes_add_array.py b/tests/basics/bytes_add_array.py
new file mode 100644
index 0000000000..2b8cbccef5
--- /dev/null
+++ b/tests/basics/bytes_add_array.py
@@ -0,0 +1,12 @@
+# test bytes + other
+try:
+    import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# should be byteorder-neutral
+print(b"123" + array.array('h', [0x1515]))
+
+print(b"\x01\x02" + array.array('b', [1, 2]))
diff --git a/tests/basics/bytes_add_endian.py b/tests/basics/bytes_add_endian.py
index 5471280d93..1bbd0f2c3a 100644
--- a/tests/basics/bytes_add_endian.py
+++ b/tests/basics/bytes_add_endian.py
@@ -1,5 +1,9 @@
 # test bytes + other
-
-import array
+try:
+    import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 print(b"123" + array.array('i', [1]))
diff --git a/tests/basics/bytes_compare2.py b/tests/basics/bytes_compare2.py
index 8959da3ae7..4d5de21d21 100644
--- a/tests/basics/bytes_compare2.py
+++ b/tests/basics/bytes_compare2.py
@@ -3,9 +3,3 @@ print(b"123" == bytearray(b"123"))
 print(b'123' < bytearray(b"124"))
 print(b'123' > bytearray(b"122"))
 print(bytearray(b"23") in b"1234")
-
-import array
-
-print(array.array('b', [1, 2]) in b'\x01\x02\x03')
-# CPython gives False here
-#print(b"\x01\x02\x03" == array.array("B", [1, 2, 3]))
diff --git a/tests/basics/bytes_compare_array.py b/tests/basics/bytes_compare_array.py
new file mode 100644
index 0000000000..ad41d1d375
--- /dev/null
+++ b/tests/basics/bytes_compare_array.py
@@ -0,0 +1,10 @@
+try:
+    import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+print(array.array('b', [1, 2]) in b'\x01\x02\x03')
+# CPython gives False here
+#print(b"\x01\x02\x03" == array.array("B", [1, 2, 3]))
diff --git a/tests/basics/bytes_construct.py b/tests/basics/bytes_construct.py
index 59e02f063c..0d638c08f2 100644
--- a/tests/basics/bytes_construct.py
+++ b/tests/basics/bytes_construct.py
@@ -1,19 +1,10 @@
 # test construction of bytes from different objects
 
-from array import array
-
 # tuple, list, bytearray
 print(bytes((1, 2)))
 print(bytes([1, 2]))
 print(bytes(bytearray(4)))
 
-# arrays
-print(bytes(array('b', [1, 2])))
-print(bytes(array('h', [0x101, 0x202])))
-
-# long ints
-print(ord(bytes([14953042807679334000 & 0xff])))
-
 # constructor value out of range
 try:
     bytes([-1])
diff --git a/tests/basics/bytes_construct_array.py b/tests/basics/bytes_construct_array.py
new file mode 100644
index 0000000000..72c2d0c585
--- /dev/null
+++ b/tests/basics/bytes_construct_array.py
@@ -0,0 +1,11 @@
+# test construction of bytes from different objects
+try:
+    from array import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# arrays
+print(bytes(array('b', [1, 2])))
+print(bytes(array('h', [0x101, 0x202])))
diff --git a/tests/basics/bytes_construct_endian.py b/tests/basics/bytes_construct_endian.py
index 1912f63a4d..77e0eaaa56 100644
--- a/tests/basics/bytes_construct_endian.py
+++ b/tests/basics/bytes_construct_endian.py
@@ -1,6 +1,11 @@
 # test construction of bytes from different objects
 
-from array import array
+try:
+    from array import array
+except ImportError:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 # arrays
 print(bytes(array('h', [1, 2])))
diff --git a/tests/basics/bytes_construct_intbig.py b/tests/basics/bytes_construct_intbig.py
new file mode 100644
index 0000000000..c32de185ff
--- /dev/null
+++ b/tests/basics/bytes_construct_intbig.py
@@ -0,0 +1,4 @@
+# test construction of bytes from different objects
+
+# long ints
+print(ord(bytes([14953042807679334000 & 0xff])))
diff --git a/tests/basics/class_delattr_setattr.py b/tests/basics/class_delattr_setattr.py
new file mode 100644
index 0000000000..0d061aee68
--- /dev/null
+++ b/tests/basics/class_delattr_setattr.py
@@ -0,0 +1,63 @@
+# test __delattr__ and __setattr__
+
+# feature test for __setattr__/__delattr__
+try:
+    class Test():
+        def __delattr__(self, attr): pass
+    del Test().noexist
+except AttributeError:
+    import sys
+    print('SKIP')
+    sys.exit()
+
+# this class just prints the calls to see if they were executed
+class A():
+    def __getattr__(self, attr):
+        print('get', attr)
+        return 1
+    def __setattr__(self, attr, val):
+        print('set', attr, val)
+    def __delattr__(self, attr):
+        print('del', attr)
+a = A()
+
+# check basic behaviour
+print(getattr(a, 'foo'))
+setattr(a, 'bar', 2)
+delattr(a, 'baz')
+
+# check meta behaviour
+getattr(a, '__getattr__') # should not call A.__getattr__
+getattr(a, '__setattr__') # should not call A.__getattr__
+getattr(a, '__delattr__') # should not call A.__getattr__
+setattr(a, '__setattr__', 1) # should call A.__setattr__
+delattr(a, '__delattr__') # should call A.__delattr__
+
+# this class acts like a dictionary
+class B:
+    def __init__(self, d):
+        # store the dict in the class, not instance, so
+        # we don't get infinite recursion in __getattr_
+        B.d = d
+
+    def __getattr__(self, attr):
+        if attr in B.d:
+            return B.d[attr]
+        else:
+            raise AttributeError(attr)
+
+    def __setattr__(self, attr, value):
+        B.d[attr] = value
+
+    def __delattr__(self, attr):
+        del B.d[attr]
+
+a = B({"a":1, "b":2})
+print(a.a, a.b)
+a.a = 3
+print(a.a, a.b)
+del a.a
+try:
+    print(a.a)
+except AttributeError:
+    print("AttributeError")
diff --git a/tests/basics/class_descriptor.py b/tests/basics/class_descriptor.py
index 25b373e47e..7f295f071e 100644
--- a/tests/basics/class_descriptor.py
+++ b/tests/basics/class_descriptor.py
@@ -18,6 +18,13 @@ class Main:
     Forward = Descriptor()
 
 m = Main()
+try:
+    m.__class__
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
 r = m.Forward
 if 'Descriptor' in repr(r.__class__):
     print('SKIP')
diff --git a/tests/basics/class_new.py b/tests/basics/class_new.py
index a6a34c5811..0198456b24 100644
--- a/tests/basics/class_new.py
+++ b/tests/basics/class_new.py
@@ -1,3 +1,11 @@
+try:
+    # If we don't expose object.__new__ (small ports), there's
+    # nothing to test.
+    object.__new__
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
 class A:
     def __new__(cls):
         print("A.__new__")
diff --git a/tests/basics/class_store_class.py b/tests/basics/class_store_class.py
index 10b94d3c6a..00a2915869 100644
--- a/tests/basics/class_store_class.py
+++ b/tests/basics/class_store_class.py
@@ -5,7 +5,12 @@
 try:
     from collections import namedtuple
 except ImportError:
-    from ucollections import namedtuple
+    try:
+        from ucollections import namedtuple
+    except ImportError:
+        import sys
+        print("SKIP")
+        sys.exit()
 
 _DefragResultBase = namedtuple('DefragResult', [ 'foo', 'bar' ])
 
diff --git a/tests/basics/class_super.py b/tests/basics/class_super.py
index 4b052d8f3c..1338ef4523 100644
--- a/tests/basics/class_super.py
+++ b/tests/basics/class_super.py
@@ -20,3 +20,17 @@ class A:
     def p(self):
         print(str(super())[:18])
 A().p()
+
+
+# test compiler's handling of long expressions with super
+class A:
+    bar = 123
+    def foo(self):
+        print('A foo')
+        return [1, 2, 3]
+class B(A):
+    def foo(self):
+        print('B foo')
+        print(super().bar) # accessing attribute after super()
+        return super().foo().count(2) # calling a subsequent method
+print(B().foo())
diff --git a/tests/basics/class_super_aslocal.py b/tests/basics/class_super_aslocal.py
new file mode 100644
index 0000000000..c9259110a8
--- /dev/null
+++ b/tests/basics/class_super_aslocal.py
@@ -0,0 +1,9 @@
+# test using the name "super" as a local variable
+
+class A:
+    def foo(self):
+        super = [1, 2]
+        super.pop()
+        print(super)
+
+A().foo()
diff --git a/tests/basics/class_super_closure.py b/tests/basics/class_super_closure.py
new file mode 100644
index 0000000000..41acae90de
--- /dev/null
+++ b/tests/basics/class_super_closure.py
@@ -0,0 +1,18 @@
+# test that no-arg super() works when self is closed over
+
+class A:
+    def __init__(self):
+        self.val = 4
+    def foo(self):
+        # we access a member of self to check that self is correct
+        return list(range(self.val))
+class B(A):
+    def foo(self):
+        # self is closed over because it's referenced in the list comprehension
+        # and then super() must detect this and load from the closure cell
+        return [self.bar(i) for i in super().foo()]
+    def bar(self, x):
+        return 2 * x
+
+print(A().foo())
+print(B().foo())
diff --git a/tests/basics/class_super_object.py b/tests/basics/class_super_object.py
index 21b97328ea..a841d34abb 100644
--- a/tests/basics/class_super_object.py
+++ b/tests/basics/class_super_object.py
@@ -1,4 +1,12 @@
 # Calling object.__init__() via super().__init__
+try:
+    # If we don't expose object.__init__ (small ports), there's
+    # nothing to test.
+    object.__init__
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 class Test(object):
     def __init__(self):
diff --git a/tests/basics/comprehension1.py b/tests/basics/comprehension1.py
index 7f541ee53f..892d6b4e33 100644
--- a/tests/basics/comprehension1.py
+++ b/tests/basics/comprehension1.py
@@ -14,7 +14,6 @@ def f():
     print(d[0], d[1], d[2], d[3], d[4])
 
     # set comprehension
-
-    print({a for a in range(5)})
+    # see set_comprehension.py
 
 f()
diff --git a/tests/basics/containment.py b/tests/basics/containment.py
index f8be04e929..bae3661131 100644
--- a/tests/basics/containment.py
+++ b/tests/basics/containment.py
@@ -1,5 +1,6 @@
+# sets, see set_containment
 for i in 1, 2:
-    for o in {1:2}, {1}, {1:2}.keys():
+    for o in {1:2}, {1:2}.keys():
         print("{} in {}: {}".format(i, o, i in o))
         print("{} not in {}: {}".format(i, o, i not in o))
 
diff --git a/tests/basics/dict_fromkeys.py b/tests/basics/dict_fromkeys.py
index bfad347c89..7b11319a23 100644
--- a/tests/basics/dict_fromkeys.py
+++ b/tests/basics/dict_fromkeys.py
@@ -7,7 +7,3 @@ d = dict.fromkeys([1, 2, 3, 4], 42)
 l = list(d.values())
 l.sort()
 print(l)
-
-# argument to fromkeys has no __len__
-d = dict.fromkeys(reversed(range(1)))
-print(d)
diff --git a/tests/basics/dict_fromkeys2.py b/tests/basics/dict_fromkeys2.py
new file mode 100644
index 0000000000..7ea0cc5b36
--- /dev/null
+++ b/tests/basics/dict_fromkeys2.py
@@ -0,0 +1,11 @@
+try:
+    reversed
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# argument to fromkeys has no __len__
+d = dict.fromkeys(reversed(range(1)))
+#d = dict.fromkeys((x for x in range(1)))
+print(d)
diff --git a/tests/basics/enumerate.py b/tests/basics/enumerate.py
index 00595cb0f6..3cc1350a0f 100644
--- a/tests/basics/enumerate.py
+++ b/tests/basics/enumerate.py
@@ -1,3 +1,10 @@
+try:
+    enumerate
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
+
 print(list(enumerate([])))
 print(list(enumerate([1, 2, 3])))
 print(list(enumerate([1, 2, 3], 5)))
diff --git a/tests/basics/filter.py b/tests/basics/filter.py
index 5883e3d00b..d0b36733c3 100644
--- a/tests/basics/filter.py
+++ b/tests/basics/filter.py
@@ -1,2 +1,9 @@
+try:
+    filter
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
+
 print(list(filter(lambda x: x & 1, range(-3, 4))))
 print(list(filter(None, range(-3, 4))))
diff --git a/tests/basics/floordivide.py b/tests/basics/floordivide.py
index 930313d6c1..60e7634b1b 100644
--- a/tests/basics/floordivide.py
+++ b/tests/basics/floordivide.py
@@ -12,18 +12,3 @@ print(a // b)
 print(a // -b)
 print(-a // b)
 print(-a // -b)
-
-if True:
-    a = 987654321987987987987987987987
-    b = 19
-
-    print(a // b)
-    print(a // -b)
-    print(-a // b)
-    print(-a // -b)
-    a = 10000000000000000000000000000000000000000000
-    b = 100
-    print(a // b)
-    print(a // -b)
-    print(-a // b)
-    print(-a // -b)    
diff --git a/tests/basics/floordivide_intbig.py b/tests/basics/floordivide_intbig.py
new file mode 100644
index 0000000000..422329fcd5
--- /dev/null
+++ b/tests/basics/floordivide_intbig.py
@@ -0,0 +1,15 @@
+# check modulo matches python definition
+
+a = 987654321987987987987987987987
+b = 19
+
+print(a // b)
+print(a // -b)
+print(-a // b)
+print(-a // -b)
+a = 10000000000000000000000000000000000000000000
+b = 100
+print(a // b)
+print(a // -b)
+print(-a // b)
+print(-a // -b)
diff --git a/tests/basics/for_range.py b/tests/basics/for_range.py
index 58a8f7caa7..fc736277d3 100644
--- a/tests/basics/for_range.py
+++ b/tests/basics/for_range.py
@@ -6,6 +6,13 @@ for x in range(*(1, 3)):
 for x in range(1, *(6, 2)):
     print(x)
 
+# zero step
+try:
+    for x in range(1, 2, 0):
+        pass
+except ValueError:
+    print('ValueError')
+
 # apply args using **
 try:
     for x in range(**{'end':1}):
diff --git a/tests/basics/fun_calldblstar3.py b/tests/basics/fun_calldblstar3.py
index 4367e68df7..b796d52c7e 100644
--- a/tests/basics/fun_calldblstar3.py
+++ b/tests/basics/fun_calldblstar3.py
@@ -5,7 +5,8 @@ def foo(**kw):
 
 class Mapping:
     def keys(self):
-        return ['a', 'b', 'c']
+        # the long string checks the case of string interning
+        return ['a', 'b', 'c', 'abcdefghijklmnopqrst']
 
     def __getitem__(self, key):
         if key == 'a':
diff --git a/tests/basics/fun_callstar.py b/tests/basics/fun_callstar.py
index 2275d3d4fc..a27a288a3c 100644
--- a/tests/basics/fun_callstar.py
+++ b/tests/basics/fun_callstar.py
@@ -17,6 +17,11 @@ foo(*range(3))
 # pos then iterator
 foo(1, *range(2, 4))
 
+# an iterator with many elements
+def foo(*rest):
+    print(rest)
+foo(*range(10))
+
 # method calls with *pos
 
 class A:
diff --git a/tests/basics/fun_error.py b/tests/basics/fun_error.py
index 305b249111..367fe0b7fa 100644
--- a/tests/basics/fun_error.py
+++ b/tests/basics/fun_error.py
@@ -27,8 +27,5 @@ 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)
-
 # kw given for positional, but a different positional is missing
 test_exc("def f(x, y): pass\nf(x=1)", TypeError)
diff --git a/tests/basics/fun_error2.py b/tests/basics/fun_error2.py
new file mode 100644
index 0000000000..c4d2c0b64d
--- /dev/null
+++ b/tests/basics/fun_error2.py
@@ -0,0 +1,19 @@
+# test errors from bad function calls
+try:
+    enumerate
+except:
+    print("SKIP")
+    import sys
+    sys.exit()
+
+def test_exc(code, exc):
+    try:
+        exec(code)
+        print("no exception")
+    except exc:
+        print("right exception")
+    except:
+        print("wrong exception")
+
+# function with keyword args not given a specific keyword arg
+test_exc("enumerate()", TypeError)
diff --git a/tests/basics/gen_yield_from_close.py b/tests/basics/gen_yield_from_close.py
index d66691ff9c..8339861056 100644
--- a/tests/basics/gen_yield_from_close.py
+++ b/tests/basics/gen_yield_from_close.py
@@ -102,7 +102,7 @@ except RuntimeError:
 
 # case where close is propagated up to a built-in iterator
 def gen8():
-    g = reversed([2, 1])
+    g = range(2)
     yield from g
 g = gen8()
 print(next(g))
diff --git a/tests/basics/gen_yield_from_throw2.py b/tests/basics/gen_yield_from_throw2.py
index 2cff9e08ba..0abfdd8cc3 100644
--- a/tests/basics/gen_yield_from_throw2.py
+++ b/tests/basics/gen_yield_from_throw2.py
@@ -1,5 +1,5 @@
-# uPy differs from CPython for this test
-# generator ignored GeneratorExit
+# generator ignores a thrown GeneratorExit (this is allowed)
+
 def gen():
     try:
         yield 123
@@ -7,9 +7,12 @@ def gen():
         print('GeneratorExit')
     yield 456
         
+# thrown a class
 g = gen()
 print(next(g))
-try:
-    g.throw(GeneratorExit)
-except RuntimeError:
-    print('RuntimeError')
+print(g.throw(GeneratorExit))
+
+# thrown an instance
+g = gen()
+print(next(g))
+print(g.throw(GeneratorExit()))
diff --git a/tests/basics/gen_yield_from_throw2.py.exp b/tests/basics/gen_yield_from_throw2.py.exp
deleted file mode 100644
index d5805b4947..0000000000
--- a/tests/basics/gen_yield_from_throw2.py.exp
+++ /dev/null
@@ -1,3 +0,0 @@
-123
-GeneratorExit
-RuntimeError
diff --git a/tests/basics/gen_yield_from_throw3.py b/tests/basics/gen_yield_from_throw3.py
new file mode 100644
index 0000000000..0f6c7c8429
--- /dev/null
+++ b/tests/basics/gen_yield_from_throw3.py
@@ -0,0 +1,30 @@
+# yield-from a user-defined generator with a throw() method
+
+class Iter:
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return 1
+
+    def throw(self, x):
+        print('throw', x)
+        return 456
+
+def gen():
+    yield from Iter()
+
+# calling close() should not call throw()
+g = gen()
+print(next(g))
+g.close()
+
+# can throw a non-exception object
+g = gen()
+print(next(g))
+print(g.throw(123))
+
+# throwing an exception class just injects that class
+g = gen()
+print(next(g))
+print(g.throw(ZeroDivisionError))
diff --git a/tests/basics/int_mpz.py b/tests/basics/int_big1.py
index 425bc21b67..425bc21b67 100644
--- a/tests/basics/int_mpz.py
+++ b/tests/basics/int_big1.py
diff --git a/tests/basics/int_bytes.py b/tests/basics/int_bytes.py
index 2f468da444..93c00bba10 100644
--- a/tests/basics/int_bytes.py
+++ b/tests/basics/int_bytes.py
@@ -1,7 +1,10 @@
 print((10).to_bytes(1, "little"))
 print((111111).to_bytes(4, "little"))
 print((100).to_bytes(10, "little"))
-print((2**64).to_bytes(9, "little"))
 print(int.from_bytes(b"\x00\x01\0\0\0\0\0\0", "little"))
 print(int.from_bytes(b"\x01\0\0\0\0\0\0\0", "little"))
 print(int.from_bytes(b"\x00\x01\0\0\0\0\0\0", "little"))
+
+# check that extra zero bytes don't change the internal int value
+print(int.from_bytes(bytes(20), "little") == 0)
+print(int.from_bytes(b"\x01" + bytes(20), "little") == 1)
diff --git a/tests/basics/int_bytes_intbig.py b/tests/basics/int_bytes_intbig.py
new file mode 100644
index 0000000000..0e0ad1cbb7
--- /dev/null
+++ b/tests/basics/int_bytes_intbig.py
@@ -0,0 +1,12 @@
+print((2**64).to_bytes(9, "little"))
+
+b = bytes(range(20))
+
+il = int.from_bytes(b, "little")
+ib = int.from_bytes(b, "big")
+print(il)
+print(ib)
+print(il.to_bytes(20, "little"))
+
+# check that extra zero bytes don't change the internal int value
+print(int.from_bytes(b + bytes(10), "little") == int.from_bytes(b, "little"))
diff --git a/tests/basics/int_bytes_notimpl.py b/tests/basics/int_bytes_notimpl.py
index b47d6ab584..b149f44966 100644
--- a/tests/basics/int_bytes_notimpl.py
+++ b/tests/basics/int_bytes_notimpl.py
@@ -2,8 +2,3 @@ try:
     print((10).to_bytes(1, "big"))
 except Exception as e:
     print(type(e))
-
-try:
-    print(int.from_bytes(b"\0", "big"))
-except Exception as e:
-    print(type(e))
diff --git a/tests/basics/int_bytes_notimpl.py.exp b/tests/basics/int_bytes_notimpl.py.exp
index d1bf338eb6..606649a693 100644
--- a/tests/basics/int_bytes_notimpl.py.exp
+++ b/tests/basics/int_bytes_notimpl.py.exp
@@ -1,2 +1 @@
 <class 'NotImplementedError'>
-<class 'NotImplementedError'>
diff --git a/tests/basics/int_constfolding.py b/tests/basics/int_constfolding.py
index aa38fa6b80..7bb5383785 100644
--- a/tests/basics/int_constfolding.py
+++ b/tests/basics/int_constfolding.py
@@ -7,19 +7,11 @@ print(+100)
 # negation
 print(-1)
 print(-(-1))
-print(-0x3fffffff) # 32-bit edge case
-print(-0x3fffffffffffffff) # 64-bit edge case
-print(-(-0x3fffffff - 1)) # 32-bit edge case
-print(-(-0x3fffffffffffffff - 1)) # 64-bit edge case
 
 # 1's complement
 print(~0)
 print(~1)
 print(~-1)
-print(~0x3fffffff) # 32-bit edge case
-print(~0x3fffffffffffffff) # 64-bit edge case
-print(~(-0x3fffffff - 1)) # 32-bit edge case
-print(~(-0x3fffffffffffffff - 1)) # 64-bit edge case
 
 # addition
 print(1 + 2)
@@ -37,9 +29,3 @@ print(123 // 7, 123 % 7)
 print(-123 // 7, -123 % 7)
 print(123 // -7, 123 % -7)
 print(-123 // -7, -123 % -7)
-
-# zero big-num on rhs
-print(1 + ((1 << 65) - (1 << 65)))
-
-# negative big-num on rhs
-print(1 + (-(1 << 65)))
diff --git a/tests/basics/int_constfolding_intbig.py b/tests/basics/int_constfolding_intbig.py
new file mode 100644
index 0000000000..714f1559a6
--- /dev/null
+++ b/tests/basics/int_constfolding_intbig.py
@@ -0,0 +1,19 @@
+# tests int constant folding in compiler
+
+# negation
+print(-0x3fffffff) # 32-bit edge case
+print(-0x3fffffffffffffff) # 64-bit edge case
+print(-(-0x3fffffff - 1)) # 32-bit edge case
+print(-(-0x3fffffffffffffff - 1)) # 64-bit edge case
+
+# 1's complement
+print(~0x3fffffff) # 32-bit edge case
+print(~0x3fffffffffffffff) # 64-bit edge case
+print(~(-0x3fffffff - 1)) # 32-bit edge case
+print(~(-0x3fffffffffffffff - 1)) # 64-bit edge case
+
+# zero big-num on rhs
+print(1 + ((1 << 65) - (1 << 65)))
+
+# negative big-num on rhs
+print(1 + (-(1 << 65)))
diff --git a/tests/basics/int_divmod.py b/tests/basics/int_divmod.py
index 3c76cd958c..2e878135f0 100644
--- a/tests/basics/int_divmod.py
+++ b/tests/basics/int_divmod.py
@@ -5,11 +5,3 @@ for i in range(-2, 3):
     for j in range(-4, 5):
         if j != 0:
             print(i, j, i // j, i % j, divmod(i, j))
-
-# this tests bignum modulo
-a = 987654321987987987987987987987
-b = 19
-print(a % b)
-print(a % -b)
-print(-a % b)
-print(-a % -b)
diff --git a/tests/basics/int_divmod_intbig.py b/tests/basics/int_divmod_intbig.py
new file mode 100644
index 0000000000..ea8de07f24
--- /dev/null
+++ b/tests/basics/int_divmod_intbig.py
@@ -0,0 +1,9 @@
+# test integer floor division and modulo
+
+# this tests bignum modulo
+a = 987654321987987987987987987987
+b = 19
+print(a % b)
+print(a % -b)
+print(-a % b)
+print(-a % -b)
diff --git a/tests/basics/int_long.py b/tests/basics/int_intbig.py
index a22075d1f9..a22075d1f9 100644
--- a/tests/basics/int_long.py
+++ b/tests/basics/int_intbig.py
diff --git a/tests/basics/iter0.py b/tests/basics/iter0.py
index 6110e8fa58..d20ade7fee 100644
--- a/tests/basics/iter0.py
+++ b/tests/basics/iter0.py
@@ -4,3 +4,6 @@ try:
         pass
 except TypeError:
     print('TypeError')
+
+# builtin type that is iterable, calling __next__ explicitly
+print(iter(range(4)).__next__())
diff --git a/tests/basics/iter_of_iter.py b/tests/basics/iter_of_iter.py
index 70282aa97e..d775b6a44e 100644
--- a/tests/basics/iter_of_iter.py
+++ b/tests/basics/iter_of_iter.py
@@ -4,5 +4,4 @@ i = iter(iter([1, 2, 3]))
 print(list(i))
 i = iter(iter({1:2, 3:4, 5:6}))
 print(sorted(i))
-i = iter(iter({1, 2, 3}))
-print(sorted(i))
+# set, see set_iter_of_iter.py
diff --git a/tests/basics/lexer.py b/tests/basics/lexer.py
index 5f12afa70f..244de8cb98 100644
--- a/tests/basics/lexer.py
+++ b/tests/basics/lexer.py
@@ -9,6 +9,14 @@ exec("\n")
 exec("\n\n")
 exec("\r")
 exec("\r\r")
+exec("\t")
+exec("\r\n")
+exec("\nprint(1)")
+exec("\rprint(2)")
+exec("\r\nprint(3)")
+exec("\n5")
+exec("\r6")
+exec("\r\n7")
 print(eval("1"))
 print(eval("12"))
 print(eval("123"))
@@ -19,6 +27,14 @@ print(eval("1\r"))
 print(eval("12\r"))
 print(eval("123\r"))
 
+# line continuation
+print(eval("'123' \\\r '456'"))
+print(eval("'123' \\\n '456'"))
+print(eval("'123' \\\r\n '456'"))
+print(eval("'123'\\\r'456'"))
+print(eval("'123'\\\n'456'"))
+print(eval("'123'\\\r\n'456'"))
+
 # backslash used to escape a line-break in a string
 print('a\
 b')
diff --git a/tests/basics/list_slice_3arg.py b/tests/basics/list_slice_3arg.py
index 8578d5855e..a5eda8034d 100644
--- a/tests/basics/list_slice_3arg.py
+++ b/tests/basics/list_slice_3arg.py
@@ -26,3 +26,14 @@ print(x[-1:-1:-1])
 print(x[-1:-2:-1])
 print(x[-1:-11:-1])
 print(x[-10:-11:-1])
+print(x[:-15:-1])
+
+# test negative indices that are out-of-bounds
+print([][::-1])
+print([1][::-1])
+print([][0:-10:-1])
+print([1][0:-10:-1])
+print([][:-20:-1])
+print([1][:-20:-1])
+print([][-20::-1])
+print([1][-20::-1])
diff --git a/tests/basics/list_slice_assign.py b/tests/basics/list_slice_assign.py
index baa9a00810..1ad1ef27c1 100644
--- a/tests/basics/list_slice_assign.py
+++ b/tests/basics/list_slice_assign.py
@@ -34,3 +34,14 @@ print(l)
 l = list(x)
 del l[:-3]
 print(l)
+
+# assign a tuple
+l = [1, 2, 3]
+l[0:1] = (10, 11, 12)
+print(l)
+
+# RHS of slice must be an iterable
+try:
+    [][0:1] = 123
+except TypeError:
+    print('TypeError')
diff --git a/tests/basics/list_slice_assign_grow.py b/tests/basics/list_slice_assign_grow.py
index 12b1541e35..fa256235ff 100644
--- a/tests/basics/list_slice_assign_grow.py
+++ b/tests/basics/list_slice_assign_grow.py
@@ -26,3 +26,8 @@ print(l)
 l = list(x)
 l[100:100] = [10, 20, 30, 40]
 print(l)
+
+# growing by using itself on RHS
+l = list(range(10))
+l[4:] = l
+print(l)
diff --git a/tests/basics/map.py b/tests/basics/map.py
index 62dca44ede..8fce352c28 100644
--- a/tests/basics/map.py
+++ b/tests/basics/map.py
@@ -1,4 +1,4 @@
 print(list(map(lambda x: x & 1, range(-3, 4))))
 print(list(map(abs, range(-3, 4))))
-print(list(map(set, [[i] for i in range(-3, 4)])))
+print(list(map(tuple, [[i] for i in range(-3, 4)])))
 print(list(map(pow, range(4), range(4))))
diff --git a/tests/basics/memoryview1.py b/tests/basics/memoryview1.py
index 1cd411195d..a771acdda9 100644
--- a/tests/basics/memoryview1.py
+++ b/tests/basics/memoryview1.py
@@ -1,4 +1,10 @@
 # test memoryview
+try:
+    memoryview
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 # test reading from bytes
 b = b'1234'
@@ -12,6 +18,10 @@ try:
     m[0] = 1
 except TypeError:
     print("TypeError")
+try:
+    m[0:2] = b'00'
+except TypeError:
+    print("TypeError")
 
 # test writing to bytearray
 b = bytearray(b)
diff --git a/tests/basics/memoryview2.py b/tests/basics/memoryview2.py
index 5117d7a680..4b5af852b2 100644
--- a/tests/basics/memoryview2.py
+++ b/tests/basics/memoryview2.py
@@ -1,13 +1,14 @@
 # test memoryview accessing maximum values for signed/unsigned elements
-
-from array import array
+try:
+    from array import array
+    memoryview
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 print(list(memoryview(b'\x7f\x80\x81\xff')))
 print(list(memoryview(array('b', [0x7f, -0x80]))))
 print(list(memoryview(array('B', [0x7f, 0x80, 0x81, 0xff]))))
 print(list(memoryview(array('h', [0x7f00, -0x8000]))))
 print(list(memoryview(array('H', [0x7f00, 0x8000, 0x8100, 0xffff]))))
-
-# these constructors give an internal overflow in uPy
-#print(list(memoryview(array('i', [0x7f000000, -0x80000000]))))
-#print(list(memoryview(array('I', [0x7f000000, 0x80000000, 0x81000000, 0xffffffff]))))
diff --git a/tests/basics/memoryview_gc.py b/tests/basics/memoryview_gc.py
index a1e4baad47..9d4857e362 100644
--- a/tests/basics/memoryview_gc.py
+++ b/tests/basics/memoryview_gc.py
@@ -1,4 +1,10 @@
 # test memoryview retains pointer to original object/buffer
+try:
+    memoryview
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 b = bytearray(10)
 m = memoryview(b)[1:]
diff --git a/tests/basics/memoryview_intbig.py b/tests/basics/memoryview_intbig.py
new file mode 100644
index 0000000000..180f15d186
--- /dev/null
+++ b/tests/basics/memoryview_intbig.py
@@ -0,0 +1,11 @@
+# test memoryview accessing maximum values for signed/unsigned elements
+try:
+    from array import array
+    memoryview
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+print(list(memoryview(array('i', [0x7f000000, -0x80000000]))))
+print(list(memoryview(array('I', [0x7f000000, 0x80000000, 0x81000000, 0xffffffff]))))
diff --git a/tests/basics/namedtuple1.py b/tests/basics/namedtuple1.py
index 346e32fbfc..132dcf96b3 100644
--- a/tests/basics/namedtuple1.py
+++ b/tests/basics/namedtuple1.py
@@ -1,7 +1,12 @@
 try:
-    from collections import namedtuple
+    try:
+        from collections import namedtuple
+    except ImportError:
+        from ucollections import namedtuple
 except ImportError:
-    from ucollections import namedtuple
+    import sys
+    print("SKIP")
+    sys.exit()
 
 T = namedtuple("Tup", ["foo", "bar"])
 # CPython prints fully qualified name, what we don't bother to do so far
diff --git a/tests/basics/object_new.py b/tests/basics/object_new.py
index befb5bfc27..568feccda4 100644
--- a/tests/basics/object_new.py
+++ b/tests/basics/object_new.py
@@ -2,6 +2,14 @@
 # (non-initialized) instance of class.
 # See e.g. http://infohost.nmt.edu/tcc/help/pubs/python/web/new-new-method.html
 # TODO: Find reference in CPython docs
+try:
+    # If we don't expose object.__new__ (small ports), there's
+    # nothing to test.
+    object.__new__
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
 
 class Foo:
 
diff --git a/tests/basics/op_error.py b/tests/basics/op_error.py
index 19ce04bc52..b30b5f0a35 100644
--- a/tests/basics/op_error.py
+++ b/tests/basics/op_error.py
@@ -20,11 +20,9 @@ test_exc("False in True", TypeError)
 test_exc("1 * {}", TypeError)
 test_exc("1 in 1", TypeError)
 test_exc("bytearray() // 2", TypeError)
-test_exc("m = memoryview(bytearray())\nm += bytearray()", TypeError)
 
 # object with buffer protocol needed on rhs
 test_exc("bytearray(1) + 1", TypeError)
-test_exc("(1 << 70) in 1", TypeError)
 
 # unsupported subscription
 test_exc("1[0]", TypeError)
diff --git a/tests/basics/op_error_intbig.py b/tests/basics/op_error_intbig.py
new file mode 100644
index 0000000000..432c05a9fe
--- /dev/null
+++ b/tests/basics/op_error_intbig.py
@@ -0,0 +1,13 @@
+# test errors from bad operations (unary, binary, etc)
+
+def test_exc(code, exc):
+    try:
+        exec(code)
+        print("no exception")
+    except exc:
+        print("right exception")
+    except:
+        print("wrong exception")
+
+# object with buffer protocol needed on rhs
+test_exc("(1 << 70) in 1", TypeError)
diff --git a/tests/basics/op_error_memoryview.py b/tests/basics/op_error_memoryview.py
new file mode 100644
index 0000000000..658ededc80
--- /dev/null
+++ b/tests/basics/op_error_memoryview.py
@@ -0,0 +1,19 @@
+# test errors from bad operations (unary, binary, etc)
+try:
+    memoryview
+except:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+def test_exc(code, exc):
+    try:
+        exec(code)
+        print("no exception")
+    except exc:
+        print("right exception")
+    except:
+        print("wrong exception")
+
+# unsupported binary operators
+test_exc("m = memoryview(bytearray())\nm += bytearray()", TypeError)
diff --git a/tests/basics/ordereddict1.py b/tests/basics/ordereddict1.py
index 5e8b2413b6..7147968c58 100644
--- a/tests/basics/ordereddict1.py
+++ b/tests/basics/ordereddict1.py
@@ -9,8 +9,19 @@ except ImportError:
         sys.exit()
 
 d = OrderedDict([(10, 20), ("b", 100), (1, 2)])
+print(len(d))
 print(list(d.keys()))
 print(list(d.values()))
 del d["b"]
+print(len(d))
+print(list(d.keys()))
+print(list(d.values()))
+
+# access remaining elements after deleting
+print(d[10], d[1])
+
+# add an element after deleting
+d["abc"] = 123
+print(len(d))
 print(list(d.keys()))
 print(list(d.values()))
diff --git a/tests/basics/python34.py b/tests/basics/python34.py
index 7f7a1e015e..a23f347d64 100644
--- a/tests/basics/python34.py
+++ b/tests/basics/python34.py
@@ -1,4 +1,4 @@
-# tests that differ when running under Python 3.4 vs 3.5
+# tests that differ when running under Python 3.4 vs 3.5/3.6
 
 # from basics/fun_kwvarargs.py
 # test evaluation order of arguments (in 3.4 it's backwards, 3.5 it's fixed)
@@ -13,14 +13,15 @@ f4(*print_ret(['a', 'b']), kw_arg=print_ret(None))
 {print_ret(1):print_ret(2)}
 
 # from basics/syntaxerror.py
-# can't have multiple * or ** (in 3.5 we can)
 def test_syntax(code):
     try:
         exec(code)
     except SyntaxError:
         print("SyntaxError")
-test_syntax("f(*a, *b)")
-test_syntax("f(**a, **b)")
+test_syntax("f(*a, *b)") # can't have multiple * (in 3.5 we can)
+test_syntax("f(**a, **b)") # can't have multiple ** (in 3.5 we can)
+test_syntax("() = []") # can't assign to empty tuple (in 3.6 we can)
+test_syntax("del ()") # can't delete empty tuple (in 3.6 we can)
 
 # from basics/sys1.py
 # uPy prints version 3.4
diff --git a/tests/basics/python34.py.exp b/tests/basics/python34.py.exp
index 637f77ce86..f497df3b80 100644
--- a/tests/basics/python34.py.exp
+++ b/tests/basics/python34.py.exp
@@ -5,5 +5,7 @@ None
 1
 SyntaxError
 SyntaxError
+SyntaxError
+SyntaxError
 3.4
 3 4
diff --git a/tests/basics/set_binop.py b/tests/basics/set_binop.py
index a3657d84bd..7848920b6a 100644
--- a/tests/basics/set_binop.py
+++ b/tests/basics/set_binop.py
@@ -29,6 +29,25 @@ for s in sets:
 
 print(set('abc') == 1)
 
+# make sure inplace operators modify the set
+
+s1 = s2 = set('abc')
+s1 |= set('ad')
+print(s1 is s2, len(s1))
+
+s1 = s2 = set('abc')
+s1 ^= set('ad')
+print(s1 is s2, len(s1))
+
+s1 = s2 = set('abc')
+s1 &= set('ad')
+print(s1 is s2, len(s1))
+
+s1 = s2 = set('abc')
+s1 -= set('ad')
+print(s1 is s2, len(s1))
+
+# unsupported operator
 try:
     set('abc') * 2
 except TypeError:
diff --git a/tests/basics/set_comprehension.py b/tests/basics/set_comprehension.py
new file mode 100644
index 0000000000..12a9a29d31
--- /dev/null
+++ b/tests/basics/set_comprehension.py
@@ -0,0 +1 @@
+print({a for a in range(5)})
diff --git a/tests/basics/set_containment.py b/tests/basics/set_containment.py
new file mode 100644
index 0000000000..97694f74c5
--- /dev/null
+++ b/tests/basics/set_containment.py
@@ -0,0 +1,4 @@
+for i in 1, 2:
+    for o in {}, {1}, {2}:
+        print("{} in {}: {}".format(i, o, i in o))
+        print("{} not in {}: {}".format(i, o, i not in o))
diff --git a/tests/basics/set_iter_of_iter.py b/tests/basics/set_iter_of_iter.py
new file mode 100644
index 0000000000..e3e91fa456
--- /dev/null
+++ b/tests/basics/set_iter_of_iter.py
@@ -0,0 +1,2 @@
+i = iter(iter({1, 2, 3}))
+print(sorted(i))
diff --git a/tests/basics/slice_bignum.py b/tests/basics/slice_intbig.py
index cc820522b0..cc820522b0 100644
--- a/tests/basics/slice_bignum.py
+++ b/tests/basics/slice_intbig.py
diff --git a/tests/basics/special_methods.py b/tests/basics/special_methods.py
index 1df7a7c4c7..9f57247c12 100644
--- a/tests/basics/special_methods.py
+++ b/tests/basics/special_methods.py
@@ -105,42 +105,4 @@ cud1 > cud2
 cud1 + cud2
 cud1 - cud2
 
-# the following require MICROPY_PY_ALL_SPECIAL_METHODS
-+cud1
--cud1
-~cud1
-cud1 * cud2
-cud1 / cud2
-cud2 // cud1
-cud1 += cud2
-cud1 -= cud2
-
-# TODO: the following operations are not supported on every ports
-#
-# ne is not supported, !(eq) is called instead
-#cud1 != cud2
-#
-# binary and is not supported
-# cud1 & cud2
-#
-# binary lshift is not supported
-# cud1<<1
-#
-# modulus is not supported
-# cud1 % 2
-#
-# binary or is not supported
-# cud1 | cud2
-#
-# pow is not supported
-# cud1**2
-#
-# rshift is not suported
-# cud1>>1
-#
-# xor is not supported
-# cud1^cud2
-#
-# in the followin test, cpython still calls __eq__
-# cud3=cud1
-# cud3==cud1
+# more in special_methods2.py
diff --git a/tests/basics/special_methods2.py b/tests/basics/special_methods2.py
new file mode 100644
index 0000000000..3623b30dcc
--- /dev/null
+++ b/tests/basics/special_methods2.py
@@ -0,0 +1,145 @@
+class Cud():
+
+    def __init__(self):
+        #print("__init__ called")
+        pass
+
+    def __repr__(self):
+        print("__repr__ called")
+        return ""
+
+    def __lt__(self, other):
+        print("__lt__ called")
+
+    def __le__(self, other):
+        print("__le__ called")
+
+    def __eq__(self, other):
+        print("__eq__ called")
+
+    def __ne__(self, other):
+        print("__ne__ called")
+
+    def __ge__(self, other):
+        print("__ge__ called")
+
+    def __gt__(self, other):
+        print("__gt__ called")
+
+    def __abs__(self):
+        print("__abs__ called")
+
+    def __add__(self, other):
+        print("__add__ called")
+
+    def __and__(self, other):
+        print("__and__ called")
+
+    def __floordiv__(self, other):
+        print("__floordiv__ called")
+
+    def __index__(self, other):
+        print("__index__ called")
+
+    def __inv__(self):
+        print("__inv__ called")
+
+    def __invert__(self):
+        print("__invert__ called")
+
+    def __lshift__(self, val):
+        print("__lshift__ called")
+
+    def __mod__(self, val):
+        print("__mod__ called")
+
+    def __mul__(self, other):
+        print("__mul__ called")
+
+    def __matmul__(self, other):
+        print("__matmul__ called")
+
+    def __neg__(self):
+        print("__neg__ called")
+
+    def __or__(self, other):
+        print("__or__ called")
+
+    def __pos__(self):
+        print("__pos__ called")
+
+    def __pow__(self, val):
+        print("__pow__ called")
+
+    def __rshift__(self, val):
+        print("__rshift__ called")
+
+    def __sub__(self, other):
+        print("__sub__ called")
+
+    def __truediv__(self, other):
+        print("__truediv__ called")
+
+    def __div__(self, other):
+        print("__div__ called")
+
+    def __xor__(self, other):
+        print("__xor__ called")
+
+    def __iadd__(self, other):
+        print("__iadd__ called")
+        return self
+
+    def __isub__(self, other):
+        print("__isub__ called")
+        return self
+
+cud1 = Cud()
+cud2 = Cud()
+
+try:
+    +cud1
+except TypeError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
+# the following require MICROPY_PY_ALL_SPECIAL_METHODS
++cud1
+-cud1
+~cud1
+cud1 * cud2
+cud1 / cud2
+cud2 // cud1
+cud1 += cud2
+cud1 -= cud2
+
+# TODO: the following operations are not supported on every ports
+#
+# ne is not supported, !(eq) is called instead
+#cud1 != cud2
+#
+# binary and is not supported
+# cud1 & cud2
+#
+# binary lshift is not supported
+# cud1<<1
+#
+# modulus is not supported
+# cud1 % 2
+#
+# binary or is not supported
+# cud1 | cud2
+#
+# pow is not supported
+# cud1**2
+#
+# rshift is not suported
+# cud1>>1
+#
+# xor is not supported
+# cud1^cud2
+#
+# in the followin test, cpython still calls __eq__
+# cud3=cud1
+# cud3==cud1
diff --git a/tests/basics/string_format2.py b/tests/basics/string_format2.py
index e211535be4..881ff4f804 100644
--- a/tests/basics/string_format2.py
+++ b/tests/basics/string_format2.py
@@ -1,6 +1,6 @@
 # comprehensive functionality test for {} format string
 
-int_tests = False # these take a while, and some give wrong results
+int_tests = False # these take a while
 char_tests = True
 str_tests = True
 
diff --git a/tests/basics/string_format_modulo.py b/tests/basics/string_format_modulo.py
index 2e4909220a..77bbcfbe36 100644
--- a/tests/basics/string_format_modulo.py
+++ b/tests/basics/string_format_modulo.py
@@ -33,38 +33,11 @@ print("%c" % 48)
 print("%c" % 'a')
 print("%10s" % 'abc')
 print("%-10s" % 'abc')
-print("%d" % 10)
-print("%+d" % 10)
-print("% d" % 10)
-print("%d" % -10)
-print("%d" % True)
-print("%i" % -10)
-print("%i" % True)
-print("%u" % -10)
-print("%u" % True)
-print("%x" % 18)
-print("%o" % 18)
-print("%X" % 18)
-print("%#x" % 18)
-print("%#X" % 18)
-print("%#6o" % 18)
-print("%#6x" % 18)
-print("%#06x" % 18)
-
-print("%*d" % (5, 10))
-print("%*.*d" % (2, 2, 20))
-print("%*.*d" % (5, 8, 20))
-
-print(">%8.4d<" % -12)
-print(">% 8.4d<" % -12)
-print(">%+8.4d<" %  12)
-print(">%+8.4d<" % -12)
-print(">%08.4d<" % -12)
-print(">%08.4d<" % 12)
-print(">%-8.4d<" % -12)
-print(">%-08.4d<" % -12)
-print(">%-+08.4d<" % -12)
-print(">%-+08.4d<" %  12)
+
+# Should be able to print dicts; in this case they aren't used
+# to lookup keywords in formats like %(foo)s
+print('%s' % {})
+print('%s' % ({},))
 
 # Cases when "*" used and there's not enough values total
 try:
@@ -77,6 +50,7 @@ except TypeError:
     print("TypeError")
 
 print("%(foo)s" % {"foo": "bar", "baz": False})
+print("%s %(foo)s %(foo)s" % {"foo": 1})
 try:
     print("%(foo)s" % {})
 except KeyError:
@@ -87,6 +61,16 @@ try:
 except TypeError:
     print("TypeError")
 
+# When using %(foo)s format the single argument must be a dict
+try:
+    '%(foo)s' % 1
+except TypeError:
+    print('TypeError')
+try:
+    '%(foo)s' % ({},)
+except TypeError:
+    print('TypeError')
+
 try:
     '%(a' % {'a':1}
 except ValueError:
diff --git a/tests/basics/string_format_modulo_int.py b/tests/basics/string_format_modulo_int.py
new file mode 100644
index 0000000000..d1f29db220
--- /dev/null
+++ b/tests/basics/string_format_modulo_int.py
@@ -0,0 +1,41 @@
+# test string modulo formatting with int values
+
+# basic cases
+print("%d" % 10)
+print("%+d" % 10)
+print("% d" % 10)
+print("%d" % -10)
+print("%d" % True)
+print("%i" % -10)
+print("%i" % True)
+print("%u" % -10)
+print("%u" % True)
+print("%x" % 18)
+print("%o" % 18)
+print("%X" % 18)
+print("%#x" % 18)
+print("%#X" % 18)
+print("%#6o" % 18)
+print("%#6x" % 18)
+print("%#06x" % 18)
+
+# with *
+print("%*d" % (5, 10))
+print("%*.*d" % (2, 2, 20))
+print("%*.*d" % (5, 8, 20))
+
+# precision
+for val in (-12, 12):
+    print(">%8.4d<" % val)
+    print(">% 8.4d<" % val)
+    print(">%+8.4d<" % val)
+    print(">%08.4d<" % val)
+    print(">%-8.4d<" % val)
+    print(">%-08.4d<" % val)
+    print(">%-+08.4d<" % val)
+
+# test + option with various amount of padding
+for pad in ('', ' ', '0'):
+    for n in (1, 2, 3):
+        for val in (-1, 0, 1):
+            print(('%+' + pad + str(n) + 'd') % val)
diff --git a/tests/basics/string_join.py b/tests/basics/string_join.py
index b8694c01e0..82f1b799a0 100644
--- a/tests/basics/string_join.py
+++ b/tests/basics/string_join.py
@@ -14,6 +14,11 @@ print(','.join('abc' for i in range(5)))
 print(b','.join([b'abc', b'123']))
 
 try:
+    ''.join(None)
+except TypeError:
+    print("TypeError")
+
+try:
     print(b','.join(['abc', b'123']))
 except TypeError:
     print("TypeError")
@@ -25,3 +30,13 @@ except TypeError:
 
 # joined by the compiler
 print("a" "b")
+print("a" '''b''')
+print("a" # inline comment
+    "b")
+print("a" \
+    "b")
+
+# the following should not be joined by the compiler
+x = 'a'
+'b'
+print(x)
diff --git a/tests/basics/struct1.py b/tests/basics/struct1.py
index d89519a2fa..bb6877c785 100644
--- a/tests/basics/struct1.py
+++ b/tests/basics/struct1.py
@@ -37,34 +37,6 @@ s = struct.pack("BHBI", 10, 100, 200, 300)
 v = struct.unpack("BHBI", s)
 print(v == (10, 100, 200, 300))
 
-# check maximum pack on 32-bit machine
-print(struct.pack("<I", 2**32 - 1))
-print(struct.pack("<I", 0xffffffff))
-
-# long long ints
-print(struct.pack("<Q", 2**64 - 1))
-print(struct.pack(">Q", 2**64 - 1))
-print(struct.pack("<Q", 0xffffffffffffffff))
-print(struct.pack(">Q", 0xffffffffffffffff))
-print(struct.pack("<q", -1))
-print(struct.pack(">q", -1))
-print(struct.pack("<Q", 1234567890123456789))
-print(struct.pack("<q", -1234567890123456789))
-print(struct.pack(">Q", 1234567890123456789))
-print(struct.pack(">q", -1234567890123456789))
-print(struct.unpack("<Q", b"\x12\x34\x56\x78\x90\x12\x34\x56"))
-print(struct.unpack(">Q", b"\x12\x34\x56\x78\x90\x12\x34\x56"))
-print(struct.unpack("<q", b"\x12\x34\x56\x78\x90\x12\x34\xf6"))
-print(struct.unpack(">q", b"\xf2\x34\x56\x78\x90\x12\x34\x56"))
-
-# check maximum unpack
-print(struct.unpack("<I", b"\xff\xff\xff\xff"))
-print(struct.unpack("<Q", b"\xff\xff\xff\xff\xff\xff\xff\xff"))
-
-# check small int overflow
-print(struct.unpack("<i", b'\xff\xff\xff\x7f'))
-print(struct.unpack("<q", b'\xff\xff\xff\xff\xff\xff\xff\x7f'))
-
 # network byte order
 print(struct.pack('!i', 123))
 
diff --git a/tests/basics/struct1_intbig.py b/tests/basics/struct1_intbig.py
new file mode 100644
index 0000000000..7f4c3ce120
--- /dev/null
+++ b/tests/basics/struct1_intbig.py
@@ -0,0 +1,37 @@
+try:
+    import ustruct as struct
+except:
+    try:
+        import struct
+    except ImportError:
+        import sys
+        print("SKIP")
+        sys.exit()
+
+# check maximum pack on 32-bit machine
+print(struct.pack("<I", 2**32 - 1))
+print(struct.pack("<I", 0xffffffff))
+
+# long long ints
+print(struct.pack("<Q", 2**64 - 1))
+print(struct.pack(">Q", 2**64 - 1))
+print(struct.pack("<Q", 0xffffffffffffffff))
+print(struct.pack(">Q", 0xffffffffffffffff))
+print(struct.pack("<q", -1))
+print(struct.pack(">q", -1))
+print(struct.pack("<Q", 1234567890123456789))
+print(struct.pack("<q", -1234567890123456789))
+print(struct.pack(">Q", 1234567890123456789))
+print(struct.pack(">q", -1234567890123456789))
+print(struct.unpack("<Q", b"\x12\x34\x56\x78\x90\x12\x34\x56"))
+print(struct.unpack(">Q", b"\x12\x34\x56\x78\x90\x12\x34\x56"))
+print(struct.unpack("<q", b"\x12\x34\x56\x78\x90\x12\x34\xf6"))
+print(struct.unpack(">q", b"\xf2\x34\x56\x78\x90\x12\x34\x56"))
+
+# check maximum unpack
+print(struct.unpack("<I", b"\xff\xff\xff\xff"))
+print(struct.unpack("<Q", b"\xff\xff\xff\xff\xff\xff\xff\xff"))
+
+# check small int overflow
+print(struct.unpack("<i", b'\xff\xff\xff\x7f'))
+print(struct.unpack("<q", b'\xff\xff\xff\xff\xff\xff\xff\x7f'))
diff --git a/tests/basics/struct2.py b/tests/basics/struct2.py
index 6dd963260b..e3f8bbebfb 100644
--- a/tests/basics/struct2.py
+++ b/tests/basics/struct2.py
@@ -26,7 +26,17 @@ print(struct.calcsize('0s1s0H2H'))
 print(struct.unpack('<0s1s0H2H', b'01234'))
 print(struct.pack('<0s1s0H2H', b'abc', b'abc', 258, 515))
 
-# check that zero of an unknown type raises an exception
+# check that unknown types raise an exception
+try:
+    struct.unpack('z', b'1')
+except:
+    print('Exception')
+
+try:
+    struct.pack('z', (b'1',))
+except:
+    print('Exception')
+
 try:
     struct.calcsize('0z')
 except:
diff --git a/tests/basics/struct_micropython.py b/tests/basics/struct_micropython.py
index e3b0ea5086..53306dad67 100644
--- a/tests/basics/struct_micropython.py
+++ b/tests/basics/struct_micropython.py
@@ -18,3 +18,16 @@ o = A()
 s = struct.pack("<O", o)
 o2 = struct.unpack("<O", s)
 print(o is o2[0])
+
+# pack and unpack pointer to a string
+# This requires uctypes to get the address of the string and instead of
+# putting this in a dedicated test that can be skipped we simply pass
+# if the import fails.
+try:
+    import uctypes
+    o = uctypes.addressof('abc')
+    s = struct.pack("<S", o)
+    o2 = struct.unpack("<S", s)
+    assert o2[0] == 'abc'
+except ImportError:
+    pass
diff --git a/tests/basics/subclass_classmethod.py b/tests/basics/subclass_classmethod.py
index ae5fbd1aa3..48f164b364 100644
--- a/tests/basics/subclass_classmethod.py
+++ b/tests/basics/subclass_classmethod.py
@@ -5,6 +5,13 @@ class Base:
     def foo(cls):
         print(cls.__name__)
 
+try:
+    Base.__name__
+except AttributeError:
+    import sys
+    print("SKIP")
+    sys.exit()
+
 class Sub(Base):
     pass
 
diff --git a/tests/basics/syntaxerror.py b/tests/basics/syntaxerror.py
index e5cbbac060..4161de017b 100644
--- a/tests/basics/syntaxerror.py
+++ b/tests/basics/syntaxerror.py
@@ -46,9 +46,6 @@ test_syntax("f**2 = 1")
 # can't assign to power of composite
 test_syntax("f[0]**2 = 1")
 
-# can't assign to empty tuple
-test_syntax("() = 1")
-
 # can't have *x on RHS
 test_syntax("x = *x")
 
@@ -66,7 +63,6 @@ test_syntax("[a, b] += c")
 test_syntax("def f(a=1, b): pass")
 
 # can't delete these things
-test_syntax("del ()")
 test_syntax("del f()")
 test_syntax("del f[0]**2")
 test_syntax("del (a for a in a)")
diff --git a/tests/basics/sys1.py b/tests/basics/sys1.py
index 816c8823aa..29ef974d14 100644
--- a/tests/basics/sys1.py
+++ b/tests/basics/sys1.py
@@ -6,8 +6,18 @@ print(sys.__name__)
 print(type(sys.path))
 print(type(sys.argv))
 print(sys.byteorder in ('little', 'big'))
-print(sys.maxsize > 100)
-print(sys.implementation.name in ('cpython', 'micropython'))
+
+try:
+    print(sys.maxsize > 100)
+except AttributeError:
+    # Effectively skip subtests
+    print(True)
+
+try:
+    print(sys.implementation.name in ('cpython', 'micropython'))
+except AttributeError:
+    # Effectively skip subtests
+    print(True)
 
 try:
     sys.exit()
diff --git a/tests/basics/try_finally_loops.py b/tests/basics/try_finally_loops.py
index 06a6b4a0ce..a4b80196fe 100644
--- a/tests/basics/try_finally_loops.py
+++ b/tests/basics/try_finally_loops.py
@@ -41,3 +41,28 @@ for i in [1]:
         break
     finally:
         print('finally 4')
+
+# Test unwind-jump where there is nothing in the body of the try or finally.
+# This checks that the bytecode emitter allocates enough stack for the unwind.
+for i in [1]:
+    try:
+        break
+    finally:
+        pass
+
+# The following test checks that the globals dict is valid after a call to a
+# function that has an unwind jump.
+# There was a bug where an unwind jump would trash the globals dict upon return
+# from a function, because it used the Python-stack incorrectly.
+def f():
+    for i in [1]:
+        try:
+            break
+        finally:
+            pass
+def g():
+    global global_var
+    f()
+    print(global_var)
+global_var = 'global'
+g()
diff --git a/tests/basics/tuple1.py b/tests/basics/tuple1.py
index 2993391d53..a7956c1072 100644
--- a/tests/basics/tuple1.py
+++ b/tests/basics/tuple1.py
@@ -17,6 +17,10 @@ print(x[2:3])
 
 print(x + (10, 100, 10000))
 
+# inplace add operator
+x += (10, 11, 12)
+print(x)
+
 # construction of tuple from large iterator (tests implementation detail of uPy)
 print(tuple(range(20)))
 
diff --git a/tests/basics/unpack1.py b/tests/basics/unpack1.py
index 0e8ec592c9..1e8b53aa1a 100644
--- a/tests/basics/unpack1.py
+++ b/tests/basics/unpack1.py
@@ -41,7 +41,7 @@ a, *b, c = 24, 25, 26, 27   ; print(a, b)
 
 a = [28, 29]
 *b, = a
-print(a, b, a == b)
+print(a, b, a == b, a is b)
 
 [*a] = [1, 2, 3]
 print(a)
diff --git a/tests/basics/zip.py b/tests/basics/zip.py
index c0109094f4..958addb7af 100644
--- a/tests/basics/zip.py
+++ b/tests/basics/zip.py
@@ -1,2 +1,10 @@
+try:
+    zip
+    set
+except NameError:
+    print("SKIP")
+    import sys
+    sys.exit()
+
 print(list(zip()))
-print(list(zip([1], {2,3})))
+print(list(zip([1], set([2, 3]))))