diff --git a/poky/bitbake/lib/bb/tests/cow.py b/poky/bitbake/lib/bb/tests/cow.py
index bf6e79f..7514264 100644
--- a/poky/bitbake/lib/bb/tests/cow.py
+++ b/poky/bitbake/lib/bb/tests/cow.py
@@ -4,9 +4,17 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # Copyright 2006 Holger Freyther <freyther@handhelds.org>
+# Copyright (C) 2020  Agilent Technologies, Inc.
 #
 
+import io
+import re
+import sys
 import unittest
+import contextlib
+import collections
+
+from bb.COW import COWDictBase, COWSetBase, COWDictMeta, COWSetMeta
 
 
 class COWTestCase(unittest.TestCase):
@@ -14,11 +22,61 @@
     Test case for the COW module from mithro
     """
 
+    def setUp(self):
+        self._track_warnings = False
+        self._warning_file = io.StringIO()
+        self._unhandled_warnings = collections.deque()
+        COWDictBase.__warn__ = self._warning_file
+
+    def tearDown(self):
+        COWDictBase.__warn__ = sys.stderr
+        if self._track_warnings:
+            self._checkAllWarningsRead()
+
+    def trackWarnings(self):
+        self._track_warnings = True
+
+    def _collectWarnings(self):
+        self._warning_file.seek(0)
+        for warning in self._warning_file:
+            self._unhandled_warnings.append(warning.rstrip("\n"))
+        self._warning_file.truncate(0)
+        self._warning_file.seek(0)
+
+    def _checkAllWarningsRead(self):
+        self._collectWarnings()
+        self.assertSequenceEqual(self._unhandled_warnings, [])
+
+    @contextlib.contextmanager
+    def checkReportsWarning(self, expected_warning):
+        self._checkAllWarningsRead()
+        yield
+        self._collectWarnings()
+        warning = self._unhandled_warnings.popleft()
+        self.assertEqual(warning, expected_warning)
+
+    def checkStrOutput(self, obj, expected_levels, expected_keys):
+        if obj.__class__ is COWDictMeta:
+            expected_class_name = "COWDict"
+        elif obj.__class__ is COWSetMeta:
+            expected_class_name = "COWSet"
+        else:
+            self.fail("obj is of unknown type {0}".format(type(obj)))
+        s = str(obj)
+        regex = re.compile(r"<(\w+) Level: (\d+) Current Keys: (\d+)>")
+        match = regex.match(s)
+        self.assertIsNotNone(match, "bad str output: '{0}'".format(s))
+        class_name = match.group(1)
+        self.assertEqual(class_name, expected_class_name)
+        levels = int(match.group(2))
+        self.assertEqual(levels, expected_levels, "wrong # levels in str: '{0}'".format(s))
+        keys = int(match.group(3))
+        self.assertEqual(keys, expected_keys, "wrong # keys in str: '{0}'".format(s))
+
     def testGetSet(self):
         """
         Test and set
         """
-        from bb.COW import COWDictBase
         a = COWDictBase.copy()
 
         self.assertEqual(False, 'a' in a)
@@ -27,16 +85,14 @@
         a['b'] = 'b'
         self.assertEqual(True, 'a' in a)
         self.assertEqual(True, 'b' in a)
-        self.assertEqual('a', a['a'] )
-        self.assertEqual('b', a['b'] )
+        self.assertEqual('a', a['a'])
+        self.assertEqual('b', a['b'])
 
     def testCopyCopy(self):
         """
         Test the copy of copies
         """
 
-        from bb.COW import COWDictBase
-
         # create two COW dict 'instances'
         b = COWDictBase.copy()
         c = COWDictBase.copy()
@@ -94,30 +150,168 @@
         self.assertEqual(False, 'e' in b_2)
 
     def testCow(self):
-        from bb.COW import COWDictBase
+        self.trackWarnings()
+
         c = COWDictBase.copy()
         c['123'] = 1027
         c['other'] = 4711
-        c['d'] = { 'abc' : 10, 'bcd' : 20 }
+        c['d'] = {'abc': 10, 'bcd': 20}
 
         copy = c.copy()
 
         self.assertEqual(1027, c['123'])
         self.assertEqual(4711, c['other'])
-        self.assertEqual({'abc':10, 'bcd':20}, c['d'])
+        self.assertEqual({'abc': 10, 'bcd': 20}, c['d'])
         self.assertEqual(1027, copy['123'])
         self.assertEqual(4711, copy['other'])
-        self.assertEqual({'abc':10, 'bcd':20}, copy['d'])
+        with self.checkReportsWarning("Warning: Doing a copy because d is a mutable type."):
+            self.assertEqual({'abc': 10, 'bcd': 20}, copy['d'])
 
         # cow it now
         copy['123'] = 1028
         copy['other'] = 4712
         copy['d']['abc'] = 20
 
-
         self.assertEqual(1027, c['123'])
         self.assertEqual(4711, c['other'])
-        self.assertEqual({'abc':10, 'bcd':20}, c['d'])
+        self.assertEqual({'abc': 10, 'bcd': 20}, c['d'])
         self.assertEqual(1028, copy['123'])
         self.assertEqual(4712, copy['other'])
-        self.assertEqual({'abc':20, 'bcd':20}, copy['d'])
+        self.assertEqual({'abc': 20, 'bcd': 20}, copy['d'])
+
+    def testOriginalTestSuite(self):
+        # This test suite is a port of the original one from COW.py
+        self.trackWarnings()
+
+        a = COWDictBase.copy()
+        self.checkStrOutput(a, 1, 0)
+
+        a['a'] = 'a'
+        a['b'] = 'b'
+        a['dict'] = {}
+        self.checkStrOutput(a, 1, 4)  # 4th member is dict__mutable__
+
+        b = a.copy()
+        self.checkStrOutput(b, 2, 0)
+        b['c'] = 'b'
+        self.checkStrOutput(b, 2, 1)
+
+        with self.checkReportsWarning("Warning: If you aren't going to change any of the values call with True."):
+            self.assertListEqual(list(a.iteritems()),
+                                 [('a', 'a'),
+                                  ('b', 'b'),
+                                  ('dict', {})
+                                  ])
+
+        with self.checkReportsWarning("Warning: If you aren't going to change any of the values call with True."):
+            b_gen = b.iteritems()
+        self.assertTupleEqual(next(b_gen), ('a', 'a'))
+        self.assertTupleEqual(next(b_gen), ('b', 'b'))
+        self.assertTupleEqual(next(b_gen), ('c', 'b'))
+        with self.checkReportsWarning("Warning: Doing a copy because dict is a mutable type."):
+            self.assertTupleEqual(next(b_gen), ('dict', {}))
+        with self.assertRaises(StopIteration):
+            next(b_gen)
+
+        b['dict']['a'] = 'b'
+        b['a'] = 'c'
+
+        self.checkStrOutput(a, 1, 4)
+        self.checkStrOutput(b, 2, 3)
+
+        with self.checkReportsWarning("Warning: If you aren't going to change any of the values call with True."):
+            self.assertListEqual(list(a.iteritems()),
+                                 [('a', 'a'),
+                                  ('b', 'b'),
+                                  ('dict', {})
+                                  ])
+
+        with self.checkReportsWarning("Warning: If you aren't going to change any of the values call with True."):
+            b_gen = b.iteritems()
+        self.assertTupleEqual(next(b_gen), ('a', 'c'))
+        self.assertTupleEqual(next(b_gen), ('b', 'b'))
+        self.assertTupleEqual(next(b_gen), ('c', 'b'))
+        self.assertTupleEqual(next(b_gen), ('dict', {'a': 'b'}))
+        with self.assertRaises(StopIteration):
+            next(b_gen)
+
+        with self.assertRaises(KeyError):
+            print(b["dict2"])
+
+        a['set'] = COWSetBase()
+        a['set'].add("o1")
+        a['set'].add("o1")
+        a['set'].add("o2")
+        self.assertSetEqual(set(a['set'].itervalues()), {"o1", "o2"})
+        self.assertSetEqual(set(b['set'].itervalues()), {"o1", "o2"})
+
+        b['set'].add('o3')
+        self.assertSetEqual(set(a['set'].itervalues()), {"o1", "o2"})
+        self.assertSetEqual(set(b['set'].itervalues()), {"o1", "o2", "o3"})
+
+        a['set2'] = set()
+        a['set2'].add("o1")
+        a['set2'].add("o1")
+        a['set2'].add("o2")
+
+        # We don't expect 'a' to change anymore
+        def check_a():
+            with self.checkReportsWarning("Warning: If you aren't going to change any of the values call with True."):
+                a_gen = a.iteritems()
+                self.assertTupleEqual(next(a_gen), ('a', 'a'))
+            self.assertTupleEqual(next(a_gen), ('b', 'b'))
+            self.assertTupleEqual(next(a_gen), ('dict', {}))
+            self.assertTupleEqual(next(a_gen), ('set2', {'o1', 'o2'}))
+            a_sub_set = next(a_gen)
+            self.assertEqual(a_sub_set[0], 'set')
+            self.checkStrOutput(a_sub_set[1], 1, 2)
+            self.assertSetEqual(set(a_sub_set[1].itervalues()), {'o1', 'o2'})
+
+        check_a()
+
+        b_gen = b.iteritems(readonly=True)
+        self.assertTupleEqual(next(b_gen), ('a', 'c'))
+        self.assertTupleEqual(next(b_gen), ('b', 'b'))
+        self.assertTupleEqual(next(b_gen), ('c', 'b'))
+        self.assertTupleEqual(next(b_gen), ('dict', {'a': 'b'}))
+        self.assertTupleEqual(next(b_gen), ('set2', {'o1', 'o2'}))
+        b_sub_set = next(b_gen)
+        self.assertEqual(b_sub_set[0], 'set')
+        self.checkStrOutput(b_sub_set[1], 2, 1)
+        self.assertSetEqual(set(b_sub_set[1].itervalues()), {'o1', 'o2', 'o3'})
+
+        del b['b']
+        with self.assertRaises(KeyError):
+            print(b['b'])
+        self.assertFalse('b' in b)
+
+        check_a()
+
+        b.__revertitem__('b')
+        check_a()
+        self.assertEqual(b['b'], 'b')
+        self.assertTrue('b' in b)
+
+        b.__revertitem__('dict')
+        check_a()
+
+        b_gen = b.iteritems(readonly=True)
+        self.assertTupleEqual(next(b_gen), ('a', 'c'))
+        self.assertTupleEqual(next(b_gen), ('b', 'b'))
+        self.assertTupleEqual(next(b_gen), ('c', 'b'))
+        self.assertTupleEqual(next(b_gen), ('dict', {}))
+        self.assertTupleEqual(next(b_gen), ('set2', {'o1', 'o2'}))
+        b_sub_set = next(b_gen)
+        self.assertEqual(b_sub_set[0], 'set')
+        self.checkStrOutput(b_sub_set[1], 2, 1)
+        self.assertSetEqual(set(b_sub_set[1].itervalues()), {'o1', 'o2', 'o3'})
+
+        self.checkStrOutput(a, 1, 6)
+        self.checkStrOutput(b, 2, 3)
+
+    def testSetMethods(self):
+        s = COWSetBase()
+        with self.assertRaises(TypeError):
+            print(s.iteritems())
+        with self.assertRaises(TypeError):
+            print(s.iterkeys())
diff --git a/poky/bitbake/lib/bb/tests/data.py b/poky/bitbake/lib/bb/tests/data.py
index 5f19504..1d4a64b 100644
--- a/poky/bitbake/lib/bb/tests/data.py
+++ b/poky/bitbake/lib/bb/tests/data.py
@@ -12,6 +12,7 @@
 import bb.data
 import bb.parse
 import logging
+import os
 
 class LogRecord():
     def __enter__(self):
diff --git a/poky/bitbake/lib/bb/tests/event.py b/poky/bitbake/lib/bb/tests/event.py
index 9229b63..9ca7e9b 100644
--- a/poky/bitbake/lib/bb/tests/event.py
+++ b/poky/bitbake/lib/bb/tests/event.py
@@ -6,17 +6,18 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 
-import unittest
-import bb
-import logging
-import bb.compat
-import bb.event
+import collections
 import importlib
+import logging
+import pickle
 import threading
 import time
-import pickle
+import unittest
 from unittest.mock import Mock
 from unittest.mock import call
+
+import bb
+import bb.event
 from bb.msg import BBLogFormatter
 
 
@@ -75,7 +76,7 @@
 
     def _create_test_handlers(self):
         """ Method used to create a test handler ordered dictionary """
-        test_handlers = bb.compat.OrderedDict()
+        test_handlers = collections.OrderedDict()
         test_handlers["handler1"] = self._test_process.handler1
         test_handlers["handler2"] = self._test_process.handler2
         return test_handlers
@@ -96,7 +97,7 @@
 
     def test_clean_class_handlers(self):
         """ Test clean_class_handlers method """
-        cleanDict = bb.compat.OrderedDict()
+        cleanDict = collections.OrderedDict()
         self.assertEqual(cleanDict,
                          bb.event.clean_class_handlers())
 
diff --git a/poky/bitbake/lib/bb/tests/fetch.py b/poky/bitbake/lib/bb/tests/fetch.py
index 29c96b2..0ecf044 100644
--- a/poky/bitbake/lib/bb/tests/fetch.py
+++ b/poky/bitbake/lib/bb/tests/fetch.py
@@ -602,8 +602,8 @@
         self.assertEqual(tree, ['a', 'dir/c'])
 
     def test_local_wildcard(self):
-        tree = self.fetchUnpack(['file://a', 'file://dir/*'])
-        self.assertEqual(tree, ['a',  'dir/c', 'dir/d', 'dir/subdir/e'])
+        with self.assertRaises(bb.fetch2.ParameterError):
+            tree = self.fetchUnpack(['file://a', 'file://dir/*'])
 
     def test_local_dir(self):
         tree = self.fetchUnpack(['file://a', 'file://dir'])
@@ -1156,7 +1156,8 @@
         ("mtd-utils", "git://git.yoctoproject.org/mtd-utils.git", "ca39eb1d98e736109c64ff9c1aa2a6ecca222d8f", "")
             : "1.5.0",
         # version pattern "pkg_name-X.Y"
-        ("presentproto", "git://anongit.freedesktop.org/git/xorg/proto/presentproto", "24f3a56e541b0a9e6c6ee76081f441221a120ef9", "")
+        # mirror of git://anongit.freedesktop.org/git/xorg/proto/presentproto since network issues interfered with testing
+        ("presentproto", "git://git.yoctoproject.org/bbfetchtests-presentproto", "24f3a56e541b0a9e6c6ee76081f441221a120ef9", "")
             : "1.0",
         # version pattern "pkg_name-vX.Y.Z"
         ("dtc", "git://git.qemu.org/dtc.git", "65cc4d2748a2c2e6f27f1cf39e07a5dbabd80ebf", "")
@@ -1170,7 +1171,8 @@
         ("mobile-broadband-provider-info", "git://gitlab.gnome.org/GNOME/mobile-broadband-provider-info.git;protocol=https", "4ed19e11c2975105b71b956440acdb25d46a347d", "")
             : "20120614",
         # packages with a valid UPSTREAM_CHECK_GITTAGREGEX
-        ("xf86-video-omap", "git://anongit.freedesktop.org/xorg/driver/xf86-video-omap", "ae0394e687f1a77e966cf72f895da91840dffb8f", "(?P<pver>(\d+\.(\d\.?)*))")
+                # mirror of git://anongit.freedesktop.org/xorg/driver/xf86-video-omap since network issues interfered with testing
+        ("xf86-video-omap", "git://git.yoctoproject.org/bbfetchtests-xf86-video-omap", "ae0394e687f1a77e966cf72f895da91840dffb8f", "(?P<pver>(\d+\.(\d\.?)*))")
             : "0.4.3",
         ("build-appliance-image", "git://git.yoctoproject.org/poky", "b37dd451a52622d5b570183a81583cc34c2ff555", "(?P<pver>(([0-9][\.|_]?)+[0-9]))")
             : "11.0.0",
@@ -1262,9 +1264,7 @@
 
 
 class FetchCheckStatusTest(FetcherTest):
-    test_wget_uris = ["http://www.cups.org/software/1.7.2/cups-1.7.2-source.tar.bz2",
-                      "http://www.cups.org/",
-                      "http://downloads.yoctoproject.org/releases/sato/sato-engine-0.1.tar.gz",
+    test_wget_uris = ["http://downloads.yoctoproject.org/releases/sato/sato-engine-0.1.tar.gz",
                       "http://downloads.yoctoproject.org/releases/sato/sato-engine-0.2.tar.gz",
                       "http://downloads.yoctoproject.org/releases/sato/sato-engine-0.3.tar.gz",
                       "https://yoctoproject.org/",