micropython · dpgeorge · May 16, 2022 · Mar 18, 2022 · Apr 11, 2022 · Mar 18, 2022
diff --git a/python-stdlib/fnmatch/fnmatch.py b/python-stdlib/fnmatch/fnmatch.py
@@ -9,14 +9,26 @@
 The function translate(PATTERN) returns a regular expression
 corresponding to PATTERN.  (It does not compile it.)
 """
-import os
-import os.path
 import re
 
-# import functools
+try:
+    from os.path import normcase
+except ImportError:
+
+    def normcase(s):
+        """
+        From os.path.normcase
+        Normalize the case of a pathname. On Windows, convert all characters
+        in the pathname to lowercase, and also convert forward slashes to
+        backward slashes. On other operating systems, return the path unchanged.
+        """
+        return s
+
 
 __all__ = ["filter", "fnmatch", "fnmatchcase", "translate"]
 
+COMPAT = re.__name__ == "ure"
+
 
 def fnmatch(name, pat):
     """Test whether FILENAME matches PATTERN.
@@ -33,8 +45,8 @@ def fnmatch(name, pat):
     if the operating system requires it.
     If you don't want this, use fnmatchcase(FILENAME, PATTERN).
     """
-    name = os.path.normcase(name)
-    pat = os.path.normcase(pat)
+    name = normcase(name)
+    pat = normcase(pat)
     return fnmatchcase(name, pat)
 
 
@@ -46,16 +58,21 @@ def _compile_pattern(pat):
         res = bytes(res_str, "ISO-8859-1")
     else:
         res = translate(pat)
+    if COMPAT:
+        if res.startswith("(?ms)"):
+            res = res[5:]
+        if res.endswith("\\Z"):
+            res = res[:-2] + "$"
     return re.compile(res).match
 
 
 def filter(names, pat):
     """Return the subset of the list NAMES that match PAT."""
     result = []
-    pat = os.path.normcase(pat)
+    pat = normcase(pat)
     match = _compile_pattern(pat)
     for name in names:
-        if match(os.path.normcase(name)):
+        if match(normcase(name)):
             result.append(name)
     return result
 
@@ -104,6 +121,15 @@ def translate(pat):
                     stuff = "\\" + stuff
                 res = "%s[%s]" % (res, stuff)
         else:
-            res = res + re.escape(c)
+            try:
+                res = res + re.escape(c)
+            except AttributeError:
+                # Using ure rather than re-pcre
+                res = res + re_escape(c)
     # Original patterns is undefined, see http://bugs.python.org/issue21464
     return "(?ms)" + res + "\Z"
+
+
+def re_escape(pattern):
+    # Replacement minimal re.escape for ure compatibility
+    return re.sub(r"([\^\$\.\|\?\*\+\(\)\[\\])", r"\\\1", pattern)
diff --git a/python-stdlib/fnmatch/metadata.txt b/python-stdlib/fnmatch/metadata.txt
@@ -1,4 +1,3 @@
 srctype = cpython
 type = module
-version = 0.5.2
-depends = os, os.path, re-pcre
+version = 0.6.0
diff --git a/python-stdlib/fnmatch/setup.py b/python-stdlib/fnmatch/setup.py
@@ -10,7 +10,7 @@
 
 setup(
     name="micropython-fnmatch",
-    version="0.5.2",
+    version="0.6.0",
     description="CPython fnmatch module ported to MicroPython",
     long_description="This is a module ported from CPython standard library to be compatible with\nMicroPython interpreter. Usually, this means applying small patches for\nfeatures not supported (yet, or at all) in MicroPython. Sometimes, heavier\nchanges are required. Note that CPython modules are written with availability\nof vast resources in mind, and may not work for MicroPython ports with\nlimited heap. If you are affected by such a case, please help reimplement\nthe module from scratch.",
     url="https://github.com/micropython/micropython-lib",
@@ -21,5 +21,4 @@
     license="Python",
     cmdclass={"sdist": sdist_upip.sdist},
     py_modules=["fnmatch"],
-    install_requires=["micropython-os", "micropython-os.path", "micropython-re-pcre"],
 )
diff --git a/python-stdlib/fnmatch/test_fnmatch.py b/python-stdlib/fnmatch/test_fnmatch.py
@@ -10,7 +10,8 @@ class FnmatchTestCase(unittest.TestCase):
     def check_match(self, filename, pattern, should_match=1, fn=fnmatch):
         if should_match:
             self.assertTrue(
-                fn(filename, pattern), "expected %r to match pattern %r" % (filename, pattern)
+                fn(filename, pattern),
+                "expected %r to match pattern %r" % (filename, pattern),
             )
         else:
             self.assertTrue(
@@ -80,9 +81,9 @@ def test_filter(self):
         self.assertEqual(filter(["a", "b"], "a"), ["a"])
 
 
-def test_main():
+def main():
     support.run_unittest(FnmatchTestCase, TranslateTestCase, FilterTestCase)
 
 
 if __name__ == "__main__":
-    test_main()
+    main()
diff --git a/python-stdlib/unittest/metadata.txt b/python-stdlib/unittest/metadata.txt
@@ -1,3 +1,4 @@
 srctype = micropython-lib
 type = module
-version = 0.3.2
+version = 0.9.0
+depends = argparse, fnmatch
diff --git a/python-stdlib/unittest/setup.py b/python-stdlib/unittest/setup.py
@@ -10,7 +10,7 @@
 
 setup(
     name="micropython-unittest",
-    version="0.3.2",
+    version="0.9.0",
     description="unittest module for MicroPython",
     long_description="This is a module reimplemented specifically for MicroPython standard library,\nwith efficient and lean design in mind. Note that this module is likely work\nin progress and likely supports just a subset of CPython's corresponding\nmodule. Please help with the development if you are interested in this\nmodule.",
     url="https://github.com/micropython/micropython-lib",
@@ -21,4 +21,5 @@
     license="MIT",
     cmdclass={"sdist": sdist_upip.sdist},
     py_modules=["unittest"],
+    install_requires=["micropython-argparse", "micropython-fnmatch"],
 )
diff --git a/python-stdlib/unittest/test_unittest.py b/python-stdlib/unittest/test_unittest.py
@@ -1,4 +1,5 @@
 import unittest
+from test_unittest_isolated import global_context
 
 
 class TestUnittestAssertions(unittest.TestCase):
@@ -37,7 +38,7 @@ def test_AlmostEqual(self):
         with self.assertRaises(AssertionError):
             self.assertNotAlmostEqual(float("inf"), float("inf"))
 
-    def test_AmostEqualWithDelta(self):
+    def test_AlmostEqualWithDelta(self):
         self.assertAlmostEqual(1.1, 1.0, delta=0.5)
         self.assertAlmostEqual(1.0, 1.1, delta=0.5)
         self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
@@ -109,7 +110,70 @@ def testRaises(self):
 
     @unittest.skip("test of skipping")
     def testSkip(self):
-        self.assertFail("this should be skipped")
+        self.fail("this should be skipped")
+
+    def testAssert(self):
+
+        e1 = None
+        try:
+
+            def func_under_test(a):
+                assert a > 10
+
+            self.assertRaises(AssertionError, func_under_test, 20)
+        except AssertionError as e:
+            e1 = e
+
+        if not e1 or "not raised" not in e1.args[0]:
+            self.fail("Expected to catch lack of AssertionError from assert in func_under_test")
+
+    @unittest.expectedFailure
+    def testExpectedFailure(self):
+        self.assertEqual(1, 0)
+
+    def testExpectedFailureNot(self):
+        @unittest.expectedFailure
+        def testInner():
+            self.assertEqual(1, 1)
+
+        try:
+            testInner()
+        except:
+            pass
+        else:
+            self.fail("Unexpected success was not detected")
+
+    def test_NotChangedByOtherTest(self):
+        global global_context
+        assert global_context is None
+        global_context = True
+
+    def test_subtest_even(self):
+        """
+        Test that numbers between 0 and 5 are all even.
+        """
+        for i in range(0, 10, 2):
+            with self.subTest("Should only pass for even numbers", i=i):
+                self.assertEqual(i % 2, 0)
+
+
+class TestUnittestSetup(unittest.TestCase):
+    class_setup_var = 0
+
+    def setUpClass(self):
+        TestUnittestSetup.class_setup_var += 1
+
+    def tearDownClass(self):
+        # Not sure how to actually test this, but we can check (in the test case below)
+        # that it hasn't been run already at least.
+        TestUnittestSetup.class_setup_var = -1
+
+    def testSetUpTearDownClass_1(self):
+        assert TestUnittestSetup.class_setup_var == 1, TestUnittestSetup.class_setup_var
+
+    def testSetUpTearDownClass_2(self):
+        # Test this twice, as if setUpClass() gets run like setUp() it would be run twice
+        assert TestUnittestSetup.class_setup_var == 1, TestUnittestSetup.class_setup_var
 
 
 if __name__ == "__main__":

diff --git a/python-stdlib/unittest/test_unittest_isolated.py b/python-stdlib/unittest/test_unittest_isolated.py
@@ -0,0 +1,15 @@
+import unittest
+
+
+global_context = None
+
+
+class TestUnittestIsolated(unittest.TestCase):
+    def test_NotChangedByOtherTest(self):
+        global global_context
+        assert global_context is None
+        global_context = True
+
+
+if __name__ == "__main__":
+    unittest.main()