Esempio n. 1
0
    def test_reject_addition_of_serial_number(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = datagram_stream.SerialNumber(self.sn_bits, 2)

        with self.assertRaisesRegexp(
                TypeError,
                "only integers can be added to SerialNumber objects"):
            v1 + v2
Esempio n. 2
0
    def test_init(self):
        v = datagram_stream.SerialNumber(self.sn_bits)
        self.assertEqual(v._value, 0)
        self.assertEqual(v._mod, 2**self.sn_bits)

        v = datagram_stream.SerialNumber(self.sn_bits, 12)
        self.assertEqual(v._value, 12)
        self.assertEqual(v._mod, 2**self.sn_bits)
Esempio n. 3
0
    def test_init_rejects_out_of_bounds_value(self):
        with self.assertRaisesRegexp(
                ValueError,
                r"65536 out of bounds for SerialNumber with SERIAL_BITS=16"):
            datagram_stream.SerialNumber(self.sn_bits, 2**16)

        with self.assertRaisesRegexp(
                ValueError,
                r"-1 out of bounds for SerialNumber with SERIAL_BITS=16"):
            datagram_stream.SerialNumber(self.sn_bits, -1)
Esempio n. 4
0
    def test_subtraction_yields_correct_sign(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 464)
        v2 = datagram_stream.SerialNumber(self.sn_bits, 2)
        v3 = datagram_stream.SerialNumber(self.sn_bits, 65500)

        self.assertEqual(v1 - v2, 462)
        self.assertEqual(v2 - v1, -462)

        self.assertEqual(v1 - v3, 500)
        self.assertEqual(v3 - v1, -500)
Esempio n. 5
0
    def test_addition_of_difference_yields_original_value(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 464)
        v2 = datagram_stream.SerialNumber(self.sn_bits, 2)
        v3 = datagram_stream.SerialNumber(self.sn_bits, 65500)

        self.assertEqual(v1, (v1 - v2) + v2)
        self.assertEqual(v1, (v1 - v3) + v3)

        self.assertEqual(v2, (v2 - v1) + v1)
        self.assertEqual(v2, (v2 - v3) + v3)

        self.assertEqual(v3, (v3 - v1) + v1)
        self.assertEqual(v3, (v3 - v2) + v2)
Esempio n. 6
0
    def test_subtraction_raises_on_undefined(self):
        v1 = datagram_stream.SerialNumber(2, 0)
        v2 = datagram_stream.SerialNumber(2, 2)

        with self.assertRaisesRegexp(
                ValueError,
                r"difference between 0_\{2\} and 2_\{2\} is undefined"):
            v1 - v2

        with self.assertRaisesRegexp(
                ValueError,
                r"difference between 2_\{2\} and 0_\{2\} is undefined"):
            v2 - v1
Esempio n. 7
0
    def test_equality_to_same_bitted_SerialNumbers(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = datagram_stream.SerialNumber(self.sn_bits, 155)
        v3 = datagram_stream.SerialNumber(self.sn_bits, 156)

        self.assertNotEqual(v1, v2)
        self.assertEqual(v1, v3)

        self.assertNotEqual(v2, v1)
        self.assertNotEqual(v2, v3)

        self.assertEqual(v3, v1)
        self.assertNotEqual(v3, v2)
Esempio n. 8
0
    def test_equality_to_ints(self):
        v = datagram_stream.SerialNumber(self.sn_bits, 156)
        self.assertEqual(v, 156)
        self.assertEqual(156, v)
        self.assertFalse(v != 156)
        self.assertFalse(156 != v)

        self.assertNotEqual(v, 155)
        self.assertNotEqual(155, v)
        self.assertFalse(v == 155)
        self.assertFalse(155 == v)
Esempio n. 9
0
 def test_add_rejects_out_of_bounds_addition(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
     with self.assertRaisesRegexp(
             ValueError,
             "32768 out of bounds for addition to SerialNumber with "
             "SERIAL_BITS=16"):
         v1 + 2**15
     with self.assertRaisesRegexp(
             ValueError,
             "-32768 out of bounds for addition to SerialNumber with "
             "SERIAL_BITS=16"):
         v1 + (-2**15)
Esempio n. 10
0
 def test_sub_rejects_out_of_bounds_subtraction(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
     with self.assertRaisesRegexp(
             ValueError,
             "32768 out of bounds for subtraction from SerialNumber with "
             "SERIAL_BITS=16"):
         v1 - 2**15
     with self.assertRaisesRegexp(
             ValueError,
             "-32768 out of bounds for subtraction from SerialNumber with "
             "SERIAL_BITS=16"):
         v1 - (-2**15)
Esempio n. 11
0
    def test_rfc1982_test_cases(self):
        v0 = datagram_stream.SerialNumber(2, 0)
        v1 = datagram_stream.SerialNumber(2, 1)
        v2 = datagram_stream.SerialNumber(2, 2)
        v3 = datagram_stream.SerialNumber(2, 3)

        self.assertTrue(v1 > v0)
        self.assertTrue(v2 > v1)
        self.assertTrue(v3 > v2)
        self.assertTrue(v0 > v3)

        self.assertTrue(v1 >= v0)
        self.assertTrue(v2 >= v1)
        self.assertTrue(v3 >= v2)
        self.assertTrue(v0 >= v3)

        self.assertTrue(v0 < v1)
        self.assertTrue(v1 < v2)
        self.assertTrue(v2 < v3)
        self.assertTrue(v3 < v0)

        self.assertTrue(v0 <= v1)
        self.assertTrue(v1 <= v2)
        self.assertTrue(v2 <= v3)
        self.assertTrue(v3 <= v0)

        self.assertTrue(v0 <= v0)
        self.assertTrue(v0 >= v0)

        self.assertTrue(v1 <= v1)
        self.assertTrue(v1 >= v1)

        self.assertTrue(v2 <= v2)
        self.assertTrue(v2 >= v2)

        self.assertTrue(v3 <= v3)
        self.assertTrue(v3 >= v3)
Esempio n. 12
0
 def test_inplace_addition_creates_copy(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
     v1_ref = v1
     v1 += 1
     self.assertIsNot(v1, v1_ref)
     self.assertNotEqual(v1, v1_ref)
Esempio n. 13
0
 def test_subtraction_wraparound(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 464)
     v1 -= 500
     self.assertEqual(v1, 65500)
Esempio n. 14
0
 def test_init_rejects_non_integer_value(self):
     with self.assertRaisesRegexp(
             TypeError, r"SerialNumber objects can only hold integers"):
         datagram_stream.SerialNumber(self.sn_bits, 2.3)
Esempio n. 15
0
 def test_to_int(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
     self.assertEqual(v1, v1.to_int())
Esempio n. 16
0
 def test_addition_wraparound(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 65500)
     v1 += 500
     self.assertEqual(v1, 464)
Esempio n. 17
0
    def test_sub_plain_integer(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = v1 - 2

        self.assertEqual(v2, 154)
Esempio n. 18
0
    def test_sub_serial_number_returns_int(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = datagram_stream.SerialNumber(self.sn_bits, 2)

        self.assertIsInstance(v1 - v2, int)
Esempio n. 19
0
    def test_add_negative_integer(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = v1 + (-2)

        self.assertEqual(v2, 154)
Esempio n. 20
0
 def test_reject_rsub(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
     with self.assertRaises(TypeError):
         v2 = 2 - v1
Esempio n. 21
0
    def test_equality_to_different_bitted_SerialNumbers(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = datagram_stream.SerialNumber(15, 156)

        self.assertNotEqual(v1, v2)
        self.assertNotEqual(v2, v1)
Esempio n. 22
0
 def test_sub_rejects_non_integer_subtraction(self):
     v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
     with self.assertRaises(TypeError):
         v1 + 1.2
Esempio n. 23
0
    def test_radd_plain_integer(self):
        v1 = datagram_stream.SerialNumber(self.sn_bits, 156)
        v2 = 2 + v1

        self.assertEqual(v2, 158)