@@ -1152,16 +1152,12 @@ def _network_by_offset(self, prefix, offset):
                 ((new_netmask._ip & self.network_address._ip) >> bit_shift)
                 + offset
             ) << bit_shift
+            if not 0 <= new_ip <= self._ALL_ONES:
+                raise ValueError(error)
 
-        if new_ip < 0:
-            raise ValueError(error)
-
-        try:
-            return self.__class__(
-                f"{self._string_from_ip_int(new_ip)}/{prefix}"
-            )
-        except OverflowError:
-            raise ValueError(error) from None
+        return self.__class__(
+            f"{self._string_from_ip_int(new_ip)}/{prefix}"
+        )
 
     def next_network(self, next_prefix=None):
         """Get the next closest network with a specific prefix.
 
@@ -1595,16 +1595,17 @@ def testNextNetworkWithBadPrefix(self):
         self.assertRaises(ValueError, self.ipv6_network.next_network, 150)
 
     def testNextNetworkOutOfAddressSpace(self):
+        error = r"out of address space, cannot make another /{} network"
         ipv4 = ipaddress.IPv4Network('255.255.255.0/24')
-        self.assertRaisesRegex(
-            ValueError,
-            'out of address space, cannot make another /24 network',
-            ipv4.next_network)
+        with self.assertRaisesRegex(ValueError, error.format(24)):
+            ipv4.next_network()
+        with self.assertRaisesRegex(ValueError, error.format(25)):
+            ipv4.next_network(25)
         ipv6 = ipaddress.IPv6Network('ffff:ffff:ffff:ffff:ffff:ffff:ffff:0/112')
-        self.assertRaisesRegex(
-            ValueError,
-            'out of address space, cannot make another /112 network',
-            ipv6.next_network)
+        with self.assertRaisesRegex(ValueError, error.format(112)):
+            ipv6.next_network()
+        with self.assertRaisesRegex(ValueError, error.format(120)):
+            ipv6.next_network(120)
 
     def testPrevNetwork(self):
         ipv4 = ipaddress.IPv4Network('1.2.3.0/24')
@@ -1646,12 +1647,17 @@ def testPrevNetworkWithBadPrefix(self):
         self.assertRaises(ValueError, self.ipv6_network.prev_network, 150)
 
     def testPrevNetworkOutOfAddressSpace(self):
+        error = r"out of address space, cannot make another /{} network"
         ipv4 = ipaddress.IPv4Network('0.0.0.0/24')
-        self.assertRaises(ValueError, ipv4.prev_network)
-        self.assertRaises(ValueError, ipv4.prev_network, 25)
+        with self.assertRaisesRegex(ValueError, error.format(24)):
+            ipv4.prev_network()
+        with self.assertRaisesRegex(ValueError, error.format(25)):
+            ipv4.prev_network(25)
         ipv6 = ipaddress.IPv6Network('::/112')
-        self.assertRaises(ValueError, ipv6.prev_network)
-        self.assertRaises(ValueError, ipv6.prev_network, 112)
+        with self.assertRaisesRegex(ValueError, error.format(112)):
+            ipv6.prev_network()
+        with self.assertRaisesRegex(ValueError, error.format(120)):
+            ipv6.prev_network(120)
 
     def testFancySubnetting(self):
         self.assertEqual(sorted(self.ipv4_network.subnets(prefixlen_diff=3)),