# Import the native function.
gc.collect()
from features0 import factorial

# Free the module that contained the function.
del sys.modules["features0"]

# Run a GC cycle which should reclaim the module but not the function.

            

Reported by Pylint.

              try:
    import gc, sys, uio, uos

    sys.implementation.mpy
    uio.IOBase
    uos.mount
except (ImportError, AttributeError):
    print("SKIP")
    raise SystemExit

            

Reported by Pylint.

                  import gc, sys, uio, uos

    sys.implementation.mpy
    uio.IOBase
    uos.mount
except (ImportError, AttributeError):
    print("SKIP")
    raise SystemExit


            

Reported by Pylint.

              
    sys.implementation.mpy
    uio.IOBase
    uos.mount
except (ImportError, AttributeError):
    print("SKIP")
    raise SystemExit



            

Reported by Pylint.

                  uos.mount
except (ImportError, AttributeError):
    print("SKIP")
    raise SystemExit


class UserFile(uio.IOBase):
    def __init__(self, data):
        self.data = memoryview(data)

            

Reported by Pylint.

                      self.pos += n
        return n

    def ioctl(self, req, arg):
        return 0


class UserFS:
    def __init__(self, files):

            

Reported by Pylint.

                      self.pos += n
        return n

    def ioctl(self, req, arg):
        return 0


class UserFS:
    def __init__(self, files):

            

Reported by Pylint.

                          return (32768, 0, 0, 0, 0, 0, 0, 0, 0, 0)
        raise OSError

    def open(self, path, mode):
        return UserFile(self.files[path])


# Pre-compiled examples/natmod/features0 example for various architectures, keyed
# by the required value of sys.implementation.mpy.

            

Reported by Pylint.

              
# Allocate lots of fragmented memory to overwrite anything that was just freed by the GC.
for i in range(1000):
    []

# Run the native function, it should not have been freed or overwritten.
print(factorial(10))

# Unmount and undo path addition.

            

Reported by Pylint.

              # Test that native code loaded from a .mpy file is retained after a GC.

try:
    import gc, sys, uio, uos

    sys.implementation.mpy
    uio.IOBase
    uos.mount
except (ImportError, AttributeError):

            

Reported by Pylint.

              
# dir of subclass
class A:
    def a():
        pass
class B(A):
    def b():
        pass
d = dir(B())

            

Reported by Pylint.

                  def a():
        pass
class B(A):
    def b():
        pass
d = dir(B())
print(d.count('a'), d.count('b'))

# dir of class with multiple bases and a common parent

            

Reported by Pylint.

              
# dir of class with multiple bases and a common parent
class C(A):
    def c():
        pass
class D(B, C):
    def d():
        pass
d = dir(D())

            

Reported by Pylint.

                  def c():
        pass
class D(B, C):
    def d():
        pass
d = dir(D())
print(d.count('a'), d.count('b'), d.count('c'), d.count('d'))

            

Reported by Pylint.

              # test builtin dir

# dir of locals
print('__name__' in dir())

# dir of module
try:
    import usys as sys
except ImportError:

            

Reported by Pylint.

              # dir of type
print('append' in dir(list))

class Foo:
    def __init__(self):
        self.x = 1
foo = Foo()
print('__init__' in dir(foo))
print('x' in dir(foo))

            

Reported by Pylint.

              # dir of type
print('append' in dir(list))

class Foo:
    def __init__(self):
        self.x = 1
foo = Foo()
print('__init__' in dir(foo))
print('x' in dir(foo))

            

Reported by Pylint.

              
class Foo:
    def __init__(self):
        self.x = 1
foo = Foo()
print('__init__' in dir(foo))
print('x' in dir(foo))

# dir of subclass

            

Reported by Pylint.

              print('x' in dir(foo))

# dir of subclass
class A:
    def a():
        pass
class B(A):
    def b():
        pass

            

Reported by Pylint.

              print('x' in dir(foo))

# dir of subclass
class A:
    def a():
        pass
class B(A):
    def b():
        pass

            

Reported by Pylint.

              # Example using PIO to drive a set of WS2812 LEDs.

import array, time
from machine import Pin
import rp2

# Configure the number of WS2812 LEDs.
NUM_LEDS = 8


            

Reported by Pylint.

              
import array, time
from machine import Pin
import rp2

# Configure the number of WS2812 LEDs.
NUM_LEDS = 8



            

Reported by Pylint.

                  T1 = 2
    T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")

            

Reported by Pylint.

                  T2 = 5
    T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]

            

Reported by Pylint.

                  T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()

            

Reported by Pylint.

                  T3 = 3
    wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()

            

Reported by Pylint.

                  wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()
    # fmt: on

            

Reported by Pylint.

                  wrap_target()
    label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()
    # fmt: on

            

Reported by Pylint.

                  label("bitloop")
    out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()
    # fmt: on


            

Reported by Pylint.

                  out(x, 1)               .side(0)    [T3 - 1]
    jmp(not_x, "do_zero")   .side(1)    [T1 - 1]
    jmp("bitloop")          .side(1)    [T2 - 1]
    label("do_zero")
    nop()                   .side(0)    [T2 - 1]
    wrap()
    # fmt: on



            

Reported by Pylint.

              def h():
    return 6

print(f'no interpolation')
print(f"no interpolation")
print(f"""no interpolation""")

x, y = 1, 2
print(f'{x}')

            

Reported by Pylint.

                  return 6

print(f'no interpolation')
print(f"no interpolation")
print(f"""no interpolation""")

x, y = 1, 2
print(f'{x}')
print(f'{x:08x}')

            

Reported by Pylint.

              
print(f'no interpolation')
print(f"no interpolation")
print(f"""no interpolation""")

x, y = 1, 2
print(f'{x}')
print(f'{x:08x}')
print(f'{x=}')

            

Reported by Pylint.

              # PEP-0498 specifies that '\\' and '#' must be disallowed explicitly, whereas
# MicroPython relies on the syntax error as a result of the substitution.

print(f"\\")
print(f'#')
try:
    eval("f'{\}'")
except SyntaxError:
    print('SyntaxError')

            

Reported by Pylint.

              # MicroPython relies on the syntax error as a result of the substitution.

print(f"\\")
print(f'#')
try:
    eval("f'{\}'")
except SyntaxError:
    print('SyntaxError')
try:

            

Reported by Pylint.

              print(f"\\")
print(f'#')
try:
    eval("f'{\}'")
except SyntaxError:
    print('SyntaxError')
try:
    eval("f'{#}'")
except SyntaxError:

            

Reported by Bandit.

              print(f"\\")
print(f'#')
try:
    eval("f'{\}'")
except SyntaxError:
    print('SyntaxError')
try:
    eval("f'{#}'")
except SyntaxError:

            

Reported by Pylint.

              print(f"\\")
print(f'#')
try:
    eval("f'{\}'")
except SyntaxError:
    print('SyntaxError')
try:
    eval("f'{#}'")
except SyntaxError:

            

Reported by Pylint.

              except SyntaxError:
    print('SyntaxError')
try:
    eval("f'{#}'")
except SyntaxError:
    print('SyntaxError')


# PEP-0498 specifies that handling of double braces '{{' or '}}' should

            

Reported by Bandit.

              except SyntaxError:
    print('SyntaxError')
try:
    eval("f'{#}'")
except SyntaxError:
    print('SyntaxError')


# PEP-0498 specifies that handling of double braces '{{' or '}}' should

            

Reported by Pylint.

              RTC IRQ test for the CC3200 based boards.
"""

from machine import RTC
import machine
import os
import time

mch = os.uname().machine

            

Reported by Pylint.

              """

from machine import RTC
import machine
import os
import time

mch = os.uname().machine
if not "LaunchPad" in mch and not "WiPy" in mch:

            

Reported by Pylint.

              rtc_irq = rtc.irq(trigger=RTC.ALARM0, handler=alarm_handler)

# active mode
time.sleep_ms(1000)
rtc.alarm_cancel()
print(rtc_irq_count == 2)
rtc_irq_count = 0
rtc.alarm(time=200, repeat=True)
time.sleep_ms(1000)

            

Reported by Pylint.

              print(rtc_irq_count == 2)
rtc_irq_count = 0
rtc.alarm(time=200, repeat=True)
time.sleep_ms(1000)
rtc.alarm_cancel()
print(rtc_irq_count == 5)

rtc_irq_count = 0
rtc.alarm(time=100, repeat=True)

            

Reported by Pylint.

              
rtc_irq_count = 0
rtc.alarm(time=100, repeat=True)
time.sleep_ms(1000)
rtc.alarm_cancel()
print(rtc_irq_count == 10)

# deep sleep mode
rtc.alarm_cancel()

            

Reported by Pylint.

              rtc.alarm_cancel()
rtc_irq_count = 0
rtc.alarm(time=100, repeat=False)
time.sleep_ms(250)
print(rtc_irq_count == 1)

rtc.alarm_cancel()
t0 = rtc_ticks_ms(rtc)
rtc.alarm(time=500, repeat=False)

            

Reported by Pylint.

                  raise Exception("Board not supported!")


def rtc_ticks_ms(rtc):
    timedate = rtc.now()
    return (timedate[5] * 1000) + (timedate[6] // 1000)


rtc_irq_count = 0

            

Reported by Pylint.

              rtc_irq_count = 0


def alarm_handler(rtc_o):
    global rtc_irq
    global rtc_irq_count
    if rtc_irq.flags() & RTC.ALARM0:
        rtc_irq_count += 1


            

Reported by Pylint.

              

def alarm_handler(rtc_o):
    global rtc_irq
    global rtc_irq_count
    if rtc_irq.flags() & RTC.ALARM0:
        rtc_irq_count += 1



            

Reported by Pylint.

              
def alarm_handler(rtc_o):
    global rtc_irq
    global rtc_irq_count
    if rtc_irq.flags() & RTC.ALARM0:
        rtc_irq_count += 1


rtc = RTC()

            

Reported by Pylint.

                          else:
                DAYS_PER_MONTH[2] = 28
            for day in range(1, DAYS_PER_MONTH[month] + 1):
                secs = time.mktime((year, month, day, 0, 0, 0, 0, 0))
                if secs != seconds:
                    print(
                        "mktime failed for %d-%02d-%02d got %d expected %d"
                        % (year, month, day, secs, seconds)
                    )

            

Reported by Pylint.

                                      "mktime failed for %d-%02d-%02d got %d expected %d"
                        % (year, month, day, secs, seconds)
                    )
                tuple = time.localtime(seconds)
                secs = time.mktime(tuple)
                if secs != seconds:
                    print(
                        "localtime failed for %d-%02d-%02d got %d expected %d"
                        % (year, month, day, secs, seconds)

            

Reported by Pylint.

                                      % (year, month, day, secs, seconds)
                    )
                tuple = time.localtime(seconds)
                secs = time.mktime(tuple)
                if secs != seconds:
                    print(
                        "localtime failed for %d-%02d-%02d got %d expected %d"
                        % (year, month, day, secs, seconds)
                    )

            

Reported by Pylint.

              

def spot_test(seconds, expected_time):
    actual_time = time.localtime(seconds)
    for i in range(len(actual_time)):
        if actual_time[i] != expected_time[i]:
            print(
                "time.localtime(", seconds, ") returned", actual_time, "expecting", expected_time
            )

            

Reported by Pylint.

              # fmt: on

t1 = time.time()
time.sleep(2)
t2 = time.time()
print(abs(time.ticks_diff(t1, t2) - 2) <= 1)

t1 = time.ticks_ms()
time.sleep_ms(50)

            

Reported by Pylint.

              t1 = time.time()
time.sleep(2)
t2 = time.time()
print(abs(time.ticks_diff(t1, t2) - 2) <= 1)

t1 = time.ticks_ms()
time.sleep_ms(50)
t2 = time.ticks_ms()
print(abs(time.ticks_diff(t1, t2) - 50) <= 1)

            

Reported by Pylint.

              t2 = time.time()
print(abs(time.ticks_diff(t1, t2) - 2) <= 1)

t1 = time.ticks_ms()
time.sleep_ms(50)
t2 = time.ticks_ms()
print(abs(time.ticks_diff(t1, t2) - 50) <= 1)

t1 = time.ticks_us()

            

Reported by Pylint.

              print(abs(time.ticks_diff(t1, t2) - 2) <= 1)

t1 = time.ticks_ms()
time.sleep_ms(50)
t2 = time.ticks_ms()
print(abs(time.ticks_diff(t1, t2) - 50) <= 1)

t1 = time.ticks_us()
time.sleep_us(1000)

            

Reported by Pylint.

              
t1 = time.ticks_ms()
time.sleep_ms(50)
t2 = time.ticks_ms()
print(abs(time.ticks_diff(t1, t2) - 50) <= 1)

t1 = time.ticks_us()
time.sleep_us(1000)
t2 = time.ticks_us()

            

Reported by Pylint.

              t1 = time.ticks_ms()
time.sleep_ms(50)
t2 = time.ticks_ms()
print(abs(time.ticks_diff(t1, t2) - 50) <= 1)

t1 = time.ticks_us()
time.sleep_us(1000)
t2 = time.ticks_us()
print(time.ticks_diff(t1, t2) < 1500)

            

Reported by Pylint.

              from pyb import ADC, Timer

adct = ADC(16)  # Temperature 930 -> 20C
print(str(adct)[:19])
adcv = ADC(17)  # Voltage 1500 -> 3.3V
print(adcv)

# read single sample; 2.5V-5V is pass range
val = adcv.read()

            

Reported by Pylint.

              from pyb import ADC, Timer

adct = ADC(16)  # Temperature 930 -> 20C
print(str(adct)[:19])
adcv = ADC(17)  # Voltage 1500 -> 3.3V
print(adcv)

# read single sample; 2.5V-5V is pass range
val = adcv.read()

            

Reported by Pylint.

              
# read single sample; 2.5V-5V is pass range
val = adcv.read()
assert val > 1000 and val < 2000

# timer for read_timed
tim = Timer(5, freq=500)

# read into bytearray

            

Reported by Bandit.

              
# read single sample; 2.5V-5V is pass range
val = adcv.read()
assert val > 1000 and val < 2000

# timer for read_timed
tim = Timer(5, freq=500)

# read into bytearray

            

Reported by Pylint.

              adcv.read_timed(buf, tim)
print(len(buf))
for i in buf:
    assert i > 50 and i < 150

# read into arrays with different element sizes
import array

arv = array.array("h", 25 * [0x7FFF])

            

Reported by Pylint.

              adcv.read_timed(buf, tim)
print(len(buf))
for i in buf:
    assert i > 50 and i < 150

# read into arrays with different element sizes
import array

arv = array.array("h", 25 * [0x7FFF])

            

Reported by Bandit.

                  assert i > 50 and i < 150

# read into arrays with different element sizes
import array

arv = array.array("h", 25 * [0x7FFF])
adcv.read_timed(arv, tim)
print(len(arv))
for i in arv:

            

Reported by Pylint.

                  assert i > 50 and i < 150

# read into arrays with different element sizes
import array

arv = array.array("h", 25 * [0x7FFF])
adcv.read_timed(arv, tim)
print(len(arv))
for i in arv:

            

Reported by Pylint.

              adcv.read_timed(arv, tim)
print(len(arv))
for i in arv:
    assert i > 1000 and i < 2000

arv = array.array("i", 30 * [-1])
adcv.read_timed(arv, tim)
print(len(arv))
for i in arv:

            

Reported by Pylint.

              adcv.read_timed(arv, tim)
print(len(arv))
for i in arv:
    assert i > 1000 and i < 2000

arv = array.array("i", 30 * [-1])
adcv.read_timed(arv, tim)
print(len(arv))
for i in arv:

            

Reported by Bandit.

              Timer test for the CC3200 based boards.
"""

from machine import Timer
import os
import time

mch = os.uname().machine
if "LaunchPad" in mch:

            

Reported by Pylint.

              import os
import time

mch = os.uname().machine
if "LaunchPad" in mch:
    pwm_pin = "GP24"
elif "WiPy" in mch:
    pwm_pin = "GP24"
else:

            

Reported by Pylint.

              ch = timer_test.tim.channel(Timer.A, freq=5)
print(ch.freq() == 5)
ch.irq(handler=timer_test.timer_isr, trigger=Timer.TIMEOUT)
time.sleep_ms(1001)
print(timer_test.int_count == 5)

ch.freq(100)
timer_test.int_count = 0
time.sleep_ms(1001)

            

Reported by Pylint.

              
ch.freq(100)
timer_test.int_count = 0
time.sleep_ms(1001)
print(timer_test.int_count == 100)

ch.freq(1000)
time.sleep_ms(1500)
timer_test.int_count = 0

            

Reported by Pylint.

              print(timer_test.int_count == 100)

ch.freq(1000)
time.sleep_ms(1500)
timer_test.int_count = 0
time.sleep_ms(2000)
print(timer_test.int_count == 2000)

timer_test.tim.deinit()

            

Reported by Pylint.

              ch.freq(1000)
time.sleep_ms(1500)
timer_test.int_count = 0
time.sleep_ms(2000)
print(timer_test.int_count == 2000)

timer_test.tim.deinit()
timer_test.tim.init(mode=Timer.ONE_SHOT)
ch = timer_test.tim.channel(Timer.A, period=100000)

            

Reported by Pylint.

              ch = timer_test.tim.channel(Timer.A, period=100000)
ch.irq(handler=timer_test.timer_isr, trigger=Timer.TIMEOUT)
timer_test.int_count = 0
time.sleep_ms(101)
print(timer_test.int_count == 1)
time.sleep_ms(101)
print(timer_test.int_count == 1)
timer_test.tim.deinit()
print(timer_test.tim)

            

Reported by Pylint.

              timer_test.int_count = 0
time.sleep_ms(101)
print(timer_test.int_count == 1)
time.sleep_ms(101)
print(timer_test.int_count == 1)
timer_test.tim.deinit()
print(timer_test.tim)

# 32 bit modes

            

Reported by Pylint.

              tim = Timer(0, mode=Timer.PWM)

try:
    ch = tim.channel(TIMER_A | TIMER_B, freq=10)
except:
    print("Exception")

try:
    ch = tim.channel(TIMER_A, freq=4)

            

Reported by Pylint.

              tim = Timer(0, mode=Timer.PWM)

try:
    ch = tim.channel(TIMER_A | TIMER_B, freq=10)
except:
    print("Exception")

try:
    ch = tim.channel(TIMER_A, freq=4)

            

Reported by Pylint.

              

# 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):

            

Reported by Pylint.

              class Base:

    def __init__(self):
        self.a = 1

    def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

            

Reported by Pylint.

              class Base:

    def __init__(self):
        self.a = 1

    def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

            

Reported by Pylint.

              class Base:

    def __init__(self):
        self.a = 1

    def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

            

Reported by Pylint.

              class Base:

    def __init__(self):
        self.a = 1

    def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

            

Reported by Pylint.

                  def __init__(self):
        self.a = 1

    def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

    def meth(self):

            

Reported by Pylint.

                  def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

    def meth(self):
        print("in Sub meth")
        return super().meth()


            

Reported by Pylint.

                  def meth(self):
        print("in Base meth", self.a)

class Sub(Base):

    def meth(self):
        print("in Sub meth")
        return super().meth()


            

Reported by Pylint.

              a.meth()

# printing super
class A:
    def p(self):
        print(str(super())[:18])
A().p()



            

Reported by Pylint.

              a.meth()

# printing super
class A:
    def p(self):
        print(str(super())[:18])
A().p()



            

Reported by Pylint.

              # test micropython.schedule() function

import micropython

try:
    micropython.schedule
except AttributeError:
    print("SKIP")
    raise SystemExit

            

Reported by Pylint.

              # must schedule from within a callback to guarantee that the scheduler is locked.


def callback(arg):
    global done
    try:
        for i in range(100):
            micropython.schedule(lambda x: x, None)
    except RuntimeError:

            

Reported by Pylint.

                  micropython.schedule
except AttributeError:
    print("SKIP")
    raise SystemExit

# Basic test of scheduling a function.


def callback(arg):

            

Reported by Pylint.

              

def callback(arg):
    global done
    print(arg)
    done = True


done = False

            

Reported by Pylint.

              # that they don't execute until the outer callback is finished.


def callback_inner(arg):
    global done
    print("inner")
    done += 1



            

Reported by Pylint.

              

def callback_inner(arg):
    global done
    print("inner")
    done += 1


def callback_outer(arg):

            

Reported by Pylint.

                  done += 1


def callback_outer(arg):
    global done
    micropython.schedule(callback_inner, 0)
    # need a loop so that the VM can check for pending events
    for i in range(2):
        pass

            

Reported by Pylint.

              

def callback_outer(arg):
    global done
    micropython.schedule(callback_inner, 0)
    # need a loop so that the VM can check for pending events
    for i in range(2):
        pass
    print("outer")

            

Reported by Pylint.

                  global done
    micropython.schedule(callback_inner, 0)
    # need a loop so that the VM can check for pending events
    for i in range(2):
        pass
    print("outer")
    done += 1



            

Reported by Pylint.

              # must schedule from within a callback to guarantee that the scheduler is locked.


def callback(arg):
    global done
    try:
        for i in range(100):
            micropython.schedule(lambda x: x, None)
    except RuntimeError:

            

Reported by Pylint.