return __builtin_bswap32(a);
#else
    return (((uint8_t*)&a)[0] <<  0) |
           (((uint8_t*)&a)[1] <<  8) |
           (((uint8_t*)&a)[2] << 16) |
           (((uint8_t*)&a)[3] << 24);
#endif
}


            

Reported by Cppcheck.

                  return __builtin_bswap32(a);
#else
    return (((uint8_t*)&a)[0] <<  0) |
           (((uint8_t*)&a)[1] <<  8) |
           (((uint8_t*)&a)[2] << 16) |
           (((uint8_t*)&a)[3] << 24);
#endif
}


            

Reported by Cppcheck.

              #else
    return (((uint8_t*)&a)[0] <<  0) |
           (((uint8_t*)&a)[1] <<  8) |
           (((uint8_t*)&a)[2] << 16) |
           (((uint8_t*)&a)[3] << 24);
#endif
}

static inline uint32_t lfs2_tole32(uint32_t a) {

            

Reported by Cppcheck.

              #else
    return (((uint8_t*)&a)[0] <<  0) |
           (((uint8_t*)&a)[1] <<  8) |
           (((uint8_t*)&a)[2] << 16) |
           (((uint8_t*)&a)[3] << 24);
#endif
}

static inline uint32_t lfs2_tole32(uint32_t a) {

            

Reported by Cppcheck.

                  return (((uint8_t*)&a)[0] <<  0) |
           (((uint8_t*)&a)[1] <<  8) |
           (((uint8_t*)&a)[2] << 16) |
           (((uint8_t*)&a)[3] << 24);
#endif
}

static inline uint32_t lfs2_tole32(uint32_t a) {
    return lfs2_fromle32(a);

            

Reported by Cppcheck.

                  return (((uint8_t*)&a)[0] <<  0) |
           (((uint8_t*)&a)[1] <<  8) |
           (((uint8_t*)&a)[2] << 16) |
           (((uint8_t*)&a)[3] << 24);
#endif
}

static inline uint32_t lfs2_tole32(uint32_t a) {
    return lfs2_fromle32(a);

            

Reported by Cppcheck.

                  return a;
#else
    return (((uint8_t*)&a)[0] << 24) |
           (((uint8_t*)&a)[1] << 16) |
           (((uint8_t*)&a)[2] <<  8) |
           (((uint8_t*)&a)[3] <<  0);
#endif
}


            

Reported by Cppcheck.

                  return a;
#else
    return (((uint8_t*)&a)[0] << 24) |
           (((uint8_t*)&a)[1] << 16) |
           (((uint8_t*)&a)[2] <<  8) |
           (((uint8_t*)&a)[3] <<  0);
#endif
}


            

Reported by Cppcheck.

              #else
    return (((uint8_t*)&a)[0] << 24) |
           (((uint8_t*)&a)[1] << 16) |
           (((uint8_t*)&a)[2] <<  8) |
           (((uint8_t*)&a)[3] <<  0);
#endif
}

static inline uint32_t lfs2_tobe32(uint32_t a) {

            

Reported by Cppcheck.

              #else
    return (((uint8_t*)&a)[0] << 24) |
           (((uint8_t*)&a)[1] << 16) |
           (((uint8_t*)&a)[2] <<  8) |
           (((uint8_t*)&a)[3] <<  0);
#endif
}

static inline uint32_t lfs2_tobe32(uint32_t a) {

            

Reported by Cppcheck.

              """Test for nrf24l01 module.  Portable between MicroPython targets."""

import usys
import ustruct as struct
import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const


            

Reported by Pylint.

              """Test for nrf24l01 module.  Portable between MicroPython targets."""

import usys
import ustruct as struct
import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const


            

Reported by Pylint.

              
import usys
import ustruct as struct
import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const

# Slave pause between receiving data and checking for further packets.

            

Reported by Pylint.

              import usys
import ustruct as struct
import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const

# Slave pause between receiving data and checking for further packets.
_RX_POLL_DELAY = const(15)

            

Reported by Pylint.

              import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const

# Slave pause between receiving data and checking for further packets.
_RX_POLL_DELAY = const(15)
# Slave pauses an additional _SLAVE_SEND_DELAY ms after receiving data and before
# transmitting to allow the (remote) master time to get into receive mode. The

            

Reported by Pylint.

              

try:
    import pyb

    leds = [pyb.LED(i + 1) for i in range(4)]
except:
    leds = []


            

Reported by Pylint.

                  import pyb

    leds = [pyb.LED(i + 1) for i in range(4)]
except:
    leds = []

print("NRF24L01 test module loaded")
print("NRF24L01 pinout for test:")
print("    CE on", cfg["ce"])

            

Reported by Pylint.

              import utime
from machine import Pin, SPI
from nrf24l01 import NRF24L01
from micropython import const

# Slave pause between receiving data and checking for further packets.
_RX_POLL_DELAY = const(15)
# Slave pauses an additional _SLAVE_SEND_DELAY ms after receiving data and before
# transmitting to allow the (remote) master time to get into receive mode. The

            

Reported by Pylint.

              pipes = (b"\xe1\xf0\xf0\xf0\xf0", b"\xd2\xf0\xf0\xf0\xf0")


def master():
    csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
    ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
    if cfg["spi"] == -1:
        spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
        nrf = NRF24L01(spi, csn, ce, payload_size=8)

            

Reported by Pylint.

              
def master():
    csn = Pin(cfg["csn"], mode=Pin.OUT, value=1)
    ce = Pin(cfg["ce"], mode=Pin.OUT, value=0)
    if cfg["spi"] == -1:
        spi = SPI(-1, sck=Pin(cfg["sck"]), mosi=Pin(cfg["mosi"]), miso=Pin(cfg["miso"]))
        nrf = NRF24L01(spi, csn, ce, payload_size=8)
    else:
        nrf = NRF24L01(SPI(cfg["spi"]), csn, ce, payload_size=8)

            

Reported by Pylint.

              
# __init__ should return None
class C3:
    def __init__(self):
        return 10
try:
    C3()
except TypeError:
    print('TypeError')

            

Reported by Pylint.

              # class with __init__

class C1:
    def __init__(self):
        self.x = 1

c1 = C1()
print(type(c1) == C1)
print(c1.x)

            

Reported by Pylint.

              # class with __init__

class C1:
    def __init__(self):
        self.x = 1

c1 = C1()
print(type(c1) == C1)
print(c1.x)

            

Reported by Pylint.

              # class with __init__

class C1:
    def __init__(self):
        self.x = 1

c1 = C1()
print(type(c1) == C1)
print(c1.x)

            

Reported by Pylint.

              
class C1:
    def __init__(self):
        self.x = 1

c1 = C1()
print(type(c1) == C1)
print(c1.x)


            

Reported by Pylint.

                      self.x = 1

c1 = C1()
print(type(c1) == C1)
print(c1.x)

class C2:
    def __init__(self, x):
        self.x = x

            

Reported by Pylint.

              print(type(c1) == C1)
print(c1.x)

class C2:
    def __init__(self, x):
        self.x = x

c2 = C2(4)
print(type(c2) == C2)

            

Reported by Pylint.

              print(type(c1) == C1)
print(c1.x)

class C2:
    def __init__(self, x):
        self.x = x

c2 = C2(4)
print(type(c2) == C2)

            

Reported by Pylint.

              
class C2:
    def __init__(self, x):
        self.x = x

c2 = C2(4)
print(type(c2) == C2)
print(c2.x)


            

Reported by Pylint.

                      self.x = x

c2 = C2(4)
print(type(c2) == C2)
print(c2.x)

# __init__ should return None
class C3:
    def __init__(self):

            

Reported by Pylint.

              # Compute the Mandelbrot set, to test complex numbers


def mandelbrot(w, h):
    def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:

            

Reported by Pylint.

              # Compute the Mandelbrot set, to test complex numbers


def mandelbrot(w, h):
    def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:

            

Reported by Pylint.

              # Compute the Mandelbrot set, to test complex numbers


def mandelbrot(w, h):
    def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:

            

Reported by Pylint.

              # Compute the Mandelbrot set, to test complex numbers


def mandelbrot(w, h):
    def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:

            

Reported by Pylint.

              

def mandelbrot(w, h):
    def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:
                return i

            

Reported by Pylint.

              
def mandelbrot(w, h):
    def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:
                return i
        return 0

            

Reported by Pylint.

                  def in_set(c):
        z = 0
        for i in range(32):
            z = z * z + c
            if abs(z) > 100:
                return i
        return 0

    img = bytearray(w * h)

            

Reported by Pylint.

              
    xscale = (w - 1) / 2.4
    yscale = (h - 1) / 3.2
    for v in range(h):
        line = memoryview(img)[v * w : v * w + w]
        for u in range(w):
            c = in_set(complex(v / yscale - 2.3, u / xscale - 1.2))
            line[u] = c


            

Reported by Pylint.

                  yscale = (h - 1) / 3.2
    for v in range(h):
        line = memoryview(img)[v * w : v * w + w]
        for u in range(w):
            c = in_set(complex(v / yscale - 2.3, u / xscale - 1.2))
            line[u] = c

    return img


            

Reported by Pylint.

                  for v in range(h):
        line = memoryview(img)[v * w : v * w + w]
        for u in range(w):
            c = in_set(complex(v / yscale - 2.3, u / xscale - 1.2))
            line[u] = c

    return img



            

Reported by Pylint.

              # test constants in assembler


@micropython.asm_thumb
def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


            

Reported by Pylint.

              
@micropython.asm_thumb
def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              
@micropython.asm_thumb
def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              @micropython.asm_thumb
def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              @micropython.asm_thumb
def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


print(hex(c1()))

            

Reported by Pylint.

              # test constants in assembler


@micropython.asm_thumb
def c1():
    movwt(r0, 0xFFFFFFFF)
    movwt(r1, 0xF0000000)
    sub(r0, r0, r1)


            

Reported by Pylint.

              print(a.a, a.b)

# test that any exception raised in __getattr__ propagates out
class A:
    def __getattr__(self, attr):
        if attr == "value":
            raise ValueError(123)
        else:
            raise AttributeError(456)

            

Reported by Pylint.

              # test __getattr__

class A:
    def __init__(self, d):
        self.d = d

    def __getattr__(self, attr):
        return self.d[attr]


            

Reported by Pylint.

              # test __getattr__

class A:
    def __init__(self, d):
        self.d = d

    def __getattr__(self, attr):
        return self.d[attr]


            

Reported by Pylint.

              # test __getattr__

class A:
    def __init__(self, d):
        self.d = d

    def __getattr__(self, attr):
        return self.d[attr]


            

Reported by Pylint.

              # test __getattr__

class A:
    def __init__(self, d):
        self.d = d

    def __getattr__(self, attr):
        return self.d[attr]


            

Reported by Pylint.

              
class A:
    def __init__(self, d):
        self.d = d

    def __getattr__(self, attr):
        return self.d[attr]

a = A({'a':1, 'b':2})

            

Reported by Pylint.

              print(a.a, a.b)

# test that any exception raised in __getattr__ propagates out
class A:
    def __getattr__(self, attr):
        if attr == "value":
            raise ValueError(123)
        else:
            raise AttributeError(456)

            

Reported by Pylint.

              print(a.a, a.b)

# test that any exception raised in __getattr__ propagates out
class A:
    def __getattr__(self, attr):
        if attr == "value":
            raise ValueError(123)
        else:
            raise AttributeError(456)

            

Reported by Pylint.

              print(a.a, a.b)

# test that any exception raised in __getattr__ propagates out
class A:
    def __getattr__(self, attr):
        if attr == "value":
            raise ValueError(123)
        else:
            raise AttributeError(456)

            

Reported by Pylint.

              # test that any exception raised in __getattr__ propagates out
class A:
    def __getattr__(self, attr):
        if attr == "value":
            raise ValueError(123)
        else:
            raise AttributeError(456)
a = A()
try:

            

Reported by Pylint.

              
# from basics/sys1.py
# uPy prints version 3.4
import usys
print(usys.version[:3])
print(usys.version_info[0], usys.version_info[1])

# from basics/exception1.py
# in 3.7 no comma is printed if there is only 1 arg (in 3.4-3.6 one is printed)

            

Reported by Pylint.

                  exec
except NameError:
    print("SKIP")
    raise SystemExit

# from basics/fun_kwvarargs.py
# test evaluation order of arguments (in 3.4 it's backwards, 3.5 it's fixed)
def f4(*vargs, **kwargs):
    print(vargs, kwargs)

            

Reported by Pylint.

              f4(*print_ret(['a', 'b']), kw_arg=print_ret(None))

# test evaluation order of dictionary key/value pair (in 3.4 it's backwards)
{print_ret(1):print_ret(2)}

# from basics/syntaxerror.py
def test_syntax(code):
    try:
        exec(code)

            

Reported by Pylint.

              # from basics/syntaxerror.py
def test_syntax(code):
    try:
        exec(code)
    except SyntaxError:
        print("SyntaxError")
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("f(*a, b)") # can't have positional after *

            

Reported by Pylint.

              # from basics/syntaxerror.py
def test_syntax(code):
    try:
        exec(code)
    except SyntaxError:
        print("SyntaxError")
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("f(*a, b)") # can't have positional after *

            

Reported by Bandit.

              # tests that differ when running under Python 3.4 vs 3.5/3.6/3.7

try:
    exec
except NameError:
    print("SKIP")
    raise SystemExit

# from basics/fun_kwvarargs.py

            

Reported by Pylint.

              
# from basics/fun_kwvarargs.py
# test evaluation order of arguments (in 3.4 it's backwards, 3.5 it's fixed)
def f4(*vargs, **kwargs):
    print(vargs, kwargs)
def print_ret(x):
    print(x)
    return x
f4(*print_ret(['a', 'b']), kw_arg=print_ret(None))

            

Reported by Pylint.

              
# from basics/fun_kwvarargs.py
# test evaluation order of arguments (in 3.4 it's backwards, 3.5 it's fixed)
def f4(*vargs, **kwargs):
    print(vargs, kwargs)
def print_ret(x):
    print(x)
    return x
f4(*print_ret(['a', 'b']), kw_arg=print_ret(None))

            

Reported by Pylint.

              # test evaluation order of arguments (in 3.4 it's backwards, 3.5 it's fixed)
def f4(*vargs, **kwargs):
    print(vargs, kwargs)
def print_ret(x):
    print(x)
    return x
f4(*print_ret(['a', 'b']), kw_arg=print_ret(None))

# test evaluation order of dictionary key/value pair (in 3.4 it's backwards)

            

Reported by Pylint.

              # test evaluation order of arguments (in 3.4 it's backwards, 3.5 it's fixed)
def f4(*vargs, **kwargs):
    print(vargs, kwargs)
def print_ret(x):
    print(x)
    return x
f4(*print_ret(['a', 'b']), kw_arg=print_ret(None))

# test evaluation order of dictionary key/value pair (in 3.4 it's backwards)

            

Reported by Pylint.

                  # Pick sensible parameters given N, M
    cur_nm = (0, 0)
    param = None
    for nm, p in bm_params.items():
        if 10 * nm[0] <= 12 * N and nm[1] <= M and nm > cur_nm:
            cur_nm = nm
            param = p
    if param is None:
        print(-1, -1, "no matching params")

            

Reported by Pylint.

                      return

    # Run and time benchmark
    run, result = bm_setup(param)
    t0 = ticks_us()
    run()
    t1 = ticks_us()
    norm, out = result()
    print(ticks_diff(t1, t0), norm, out)

            

Reported by Pylint.

              def bm_run(N, M):
    try:
        from utime import ticks_us, ticks_diff
    except ImportError:
        import time

        ticks_us = lambda: int(time.perf_counter() * 1000000)
        ticks_diff = lambda a, b: a - b


            

Reported by Pylint.

              def bm_run(N, M):
    try:
        from utime import ticks_us, ticks_diff
    except ImportError:
        import time

        ticks_us = lambda: int(time.perf_counter() * 1000000)
        ticks_diff = lambda a, b: a - b


            

Reported by Pylint.

              def bm_run(N, M):
    try:
        from utime import ticks_us, ticks_diff
    except ImportError:
        import time

        ticks_us = lambda: int(time.perf_counter() * 1000000)
        ticks_diff = lambda a, b: a - b


            

Reported by Pylint.

              def bm_run(N, M):
    try:
        from utime import ticks_us, ticks_diff
    except ImportError:
        import time

        ticks_us = lambda: int(time.perf_counter() * 1000000)
        ticks_diff = lambda a, b: a - b


            

Reported by Pylint.

              def bm_run(N, M):
    try:
        from utime import ticks_us, ticks_diff
    except ImportError:
        import time

        ticks_us = lambda: int(time.perf_counter() * 1000000)
        ticks_diff = lambda a, b: a - b


            

Reported by Pylint.

                  try:
        from utime import ticks_us, ticks_diff
    except ImportError:
        import time

        ticks_us = lambda: int(time.perf_counter() * 1000000)
        ticks_diff = lambda a, b: a - b

    # Pick sensible parameters given N, M

            

Reported by Pylint.

                  # Pick sensible parameters given N, M
    cur_nm = (0, 0)
    param = None
    for nm, p in bm_params.items():
        if 10 * nm[0] <= 12 * N and nm[1] <= M and nm > cur_nm:
            cur_nm = nm
            param = p
    if param is None:
        print(-1, -1, "no matching params")

            

Reported by Pylint.

                  # Pick sensible parameters given N, M
    cur_nm = (0, 0)
    param = None
    for nm, p in bm_params.items():
        if 10 * nm[0] <= 12 * N and nm[1] <= M and nm > cur_nm:
            cur_nm = nm
            param = p
    if param is None:
        print(-1, -1, "no matching params")

            

Reported by Pylint.

              
try:
    import uerrno as errno, usocket as socket, ussl as ssl
except:
    import errno, socket, ssl


def test(addr, hostname, block=True):
    print("---", hostname or addr)

            

Reported by Pylint.

                  import errno, socket, ssl


def test(addr, hostname, block=True):
    print("---", hostname or addr)
    s = socket.socket()
    s.setblocking(block)
    try:
        s.connect(addr)

            

Reported by Pylint.

              
    try:
        if sys.implementation.name == "micropython":
            s = ssl.wrap_socket(s, do_handshake=block)
        else:
            s = ssl.wrap_socket(s, do_handshake_on_connect=block)
        print("wrap: True")
    except OSError:
        print("wrap: error")

            

Reported by Pylint.

                      if sys.implementation.name == "micropython":
            s = ssl.wrap_socket(s, do_handshake=block)
        else:
            s = ssl.wrap_socket(s, do_handshake_on_connect=block)
        print("wrap: True")
    except OSError:
        print("wrap: error")

    if not block:

            

Reported by Pylint.

              # test that socket.connect() on a non-blocking socket raises EINPROGRESS
# and that an immediate write/send/read/recv does the right thing

import sys

try:
    import uerrno as errno, usocket as socket, ussl as ssl
except:
    import errno, socket, ssl

            

Reported by Pylint.

              import sys

try:
    import uerrno as errno, usocket as socket, ussl as ssl
except:
    import errno, socket, ssl


def test(addr, hostname, block=True):

            

Reported by Pylint.

              try:
    import uerrno as errno, usocket as socket, ussl as ssl
except:
    import errno, socket, ssl


def test(addr, hostname, block=True):
    print("---", hostname or addr)
    s = socket.socket()

            

Reported by Pylint.

                  import errno, socket, ssl


def test(addr, hostname, block=True):
    print("---", hostname or addr)
    s = socket.socket()
    s.setblocking(block)
    try:
        s.connect(addr)

            

Reported by Pylint.

              
def test(addr, hostname, block=True):
    print("---", hostname or addr)
    s = socket.socket()
    s.setblocking(block)
    try:
        s.connect(addr)
        print("connected")
    except OSError as e:

            

Reported by Pylint.

                  try:
        s.connect(addr)
        print("connected")
    except OSError as e:
        if e.errno != errno.EINPROGRESS:
            raise
        print("EINPROGRESS")

    try:

            

Reported by Pylint.

                      import random
    except ImportError:
        print("SKIP")
        raise SystemExit

try:
    random.randint
except AttributeError:
    print("SKIP")

            

Reported by Pylint.

                  random.randint
except AttributeError:
    print("SKIP")
    raise SystemExit

print("randrange")
for i in range(50):
    assert 0 <= random.randrange(4) < 4
    assert 2 <= random.randrange(2, 6) < 6

            

Reported by Pylint.

              try:
    import urandom as random
except ImportError:
    try:
        import random
    except ImportError:
        print("SKIP")
        raise SystemExit


            

Reported by Pylint.

              
print("randrange")
for i in range(50):
    assert 0 <= random.randrange(4) < 4
    assert 2 <= random.randrange(2, 6) < 6
    assert -2 <= random.randrange(-2, 2) < 2
    assert random.randrange(1, 9, 2) in (1, 3, 5, 7)
    assert random.randrange(2, 1, -1) in (1, 2)


            

Reported by Bandit.

              print("randrange")
for i in range(50):
    assert 0 <= random.randrange(4) < 4
    assert 2 <= random.randrange(2, 6) < 6
    assert -2 <= random.randrange(-2, 2) < 2
    assert random.randrange(1, 9, 2) in (1, 3, 5, 7)
    assert random.randrange(2, 1, -1) in (1, 2)

# empty range

            

Reported by Bandit.

              for i in range(50):
    assert 0 <= random.randrange(4) < 4
    assert 2 <= random.randrange(2, 6) < 6
    assert -2 <= random.randrange(-2, 2) < 2
    assert random.randrange(1, 9, 2) in (1, 3, 5, 7)
    assert random.randrange(2, 1, -1) in (1, 2)

# empty range
try:

            

Reported by Bandit.

                  assert 0 <= random.randrange(4) < 4
    assert 2 <= random.randrange(2, 6) < 6
    assert -2 <= random.randrange(-2, 2) < 2
    assert random.randrange(1, 9, 2) in (1, 3, 5, 7)
    assert random.randrange(2, 1, -1) in (1, 2)

# empty range
try:
    random.randrange(0)

            

Reported by Bandit.

                  assert 2 <= random.randrange(2, 6) < 6
    assert -2 <= random.randrange(-2, 2) < 2
    assert random.randrange(1, 9, 2) in (1, 3, 5, 7)
    assert random.randrange(2, 1, -1) in (1, 2)

# empty range
try:
    random.randrange(0)
except ValueError:

            

Reported by Bandit.

              
print("randint")
for i in range(50):
    assert 0 <= random.randint(0, 4) <= 4
    assert 2 <= random.randint(2, 6) <= 6
    assert -2 <= random.randint(-2, 2) <= 2

# empty range
try:

            

Reported by Bandit.

              print("randint")
for i in range(50):
    assert 0 <= random.randint(0, 4) <= 4
    assert 2 <= random.randint(2, 6) <= 6
    assert -2 <= random.randint(-2, 2) <= 2

# empty range
try:
    random.randint(2, 1)

            

Reported by Bandit.