#
#  SelfTest/Math/test_Numbers.py: Self-test for Numbers module
#
# ===================================================================
#
# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in
#    the documentation and/or other materials provided with the
#    distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ===================================================================

"""Self-test for Math.Numbers"""

import unittest

from Crypto.SelfTest.st_common import list_test_cases

from Crypto.Util.py3compat import *

from Crypto.Math._IntegerNative import IntegerNative


class TestIntegerBase(unittest.TestCase):

    def setUp(self):
        pass

    def Integers(self, *arg):
        return map(self.Integer, arg)

    def test_init_and_equality(self):
        Integer = self.Integer

        v1 = Integer(23)
        v2 = Integer(v1)
        v3 = Integer(-9)
        self.assertRaises(ValueError, Integer, 1.0)

        v4 = Integer(10**10)
        v5 = Integer(-10**10)
        self.assertEqual(v1, v1)
        self.assertEqual(v1, 23)
        self.assertEqual(v1, v2)
        self.assertEqual(v3, -9)
        self.assertEqual(v4, 10 ** 10)
        self.assertEqual(v5, -10 ** 10)

        self.failIf(v1 == v4)

        # Init and comparison between Integer's
        v6 = Integer(v1)
        self.assertEqual(v1, v6)

        self.failIf(Integer(0) == None)

    def test_conversion_to_int(self):
        v1, v2 = self.Integers(-23, 2 ** 1000)
        self.assertEqual(int(v1), -23)
        self.assertEqual(int(v2), 2 ** 1000)

    def test_equality_with_ints(self):
        v1, v2, v3 = self.Integers(23, -89, 2 ** 1000)
        self.failUnless(v1 == 23)
        self.failUnless(v2 == -89)
        self.failIf(v1 == 24)
        self.failUnless(v3 == 2 ** 1000)

    def test_conversion_to_str(self):
        v1, v2, v3, v4 = self.Integers(20, 0, -20, 2 ** 1000)
        self.failUnless(str(v1) == "20")
        self.failUnless(str(v2) == "0")
        self.failUnless(str(v3) == "-20")
        self.failUnless(str(v4) == "10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376")

    def test_repr(self):
        v1, v2 = self.Integers(-1, 2**80)
        self.assertEqual(repr(v1), "Integer(-1)")
        self.assertEqual(repr(v2), "Integer(1208925819614629174706176)")

    def test_conversion_to_bytes(self):
        Integer = self.Integer

        v1 = Integer(0x17)
        self.assertEqual(b("\x17"), v1.to_bytes())

        v2 = Integer(0xFFFF)
        self.assertEqual(b("\xFF\xFF"), v2.to_bytes())
        self.assertEqual(b("\x00\xFF\xFF"), v2.to_bytes(3))
        self.assertRaises(ValueError, v2.to_bytes, 1)

        v3 = Integer(-90)
        self.assertRaises(ValueError, v3.to_bytes)

    def test_conversion_from_bytes(self):
        Integer = self.Integer

        v1 = Integer.from_bytes(b("\x00"))
        self.failUnless(isinstance(v1, Integer))
        self.assertEqual(0, v1)

        v2 = Integer.from_bytes(b("\x00\x00"))
        self.assertEqual(0, v2)

        v3 = Integer.from_bytes(b("\xFF\xFF"))
        self.assertEqual(0xFFFF, v3)

    def test_inequality(self):
        # Test Integer!=Integer and Integer!=int
        v1, v2, v3, v4 = self.Integers(89, 89, 90, -8)
        self.failUnless(v1 != v3)
        self.failUnless(v1 != 90)
        self.failIf(v1 != v2)
        self.failIf(v1 != 89)
        self.failUnless(v1 != v4)
        self.failUnless(v4 != v1)
        self.failUnless(self.Integer(0) != None)

    def test_less_than(self):
        # Test Integer<Integer and Integer<int
        v1, v2, v3, v4, v5 = self.Integers(13, 13, 14, -8, 2 ** 10)
        self.failUnless(v1 < v3)
        self.failUnless(v1 < 14)
        self.failIf(v1 < v2)
        self.failIf(v1 < 13)
        self.failUnless(v4 < v1)
        self.failIf(v1 < v4)
        self.failUnless(v1 < v5)
        self.failIf(v5 < v1)

    def test_less_than_or_equal(self):
        # Test Integer<=Integer and Integer<=int
        v1, v2, v3, v4, v5 = self.Integers(13, 13, 14, -4, 2 ** 10)
        self.failUnless(v1 <= v1)
        self.failUnless(v1 <= 13)
        self.failUnless(v1 <= v2)
        self.failUnless(v1 <= 14)
        self.failUnless(v1 <= v3)
        self.failIf(v1 <= v4)
        self.failUnless(v1 <= v5)
        self.failIf(v5 <= v1)

    def test_more_than(self):
        # Test Integer>Integer and Integer>int
        v1, v2, v3, v4, v5 = self.Integers(13, 13, 14, -8, 2 ** 10)
        self.failUnless(v3 > v1)
        self.failUnless(v3 > 13)
        self.failIf(v1 > v1)
        self.failIf(v1 > v2)
        self.failIf(v1 > 13)
        self.failUnless(v1 > v4)
        self.failIf(v4 > v1)
        self.failUnless(v5 > v1)
        self.failIf(v1 > v5)

    def test_more_than_or_equal(self):
        # Test Integer>=Integer and Integer>=int
        v1, v2, v3, v4 = self.Integers(13, 13, 14, -4)
        self.failUnless(v3 >= v1)
        self.failUnless(v3 >= 13)
        self.failUnless(v1 >= v2)
        self.failUnless(v1 >= v1)
        self.failUnless(v1 >= 13)
        self.failIf(v4 >= v1)

    def test_bool(self):
        v1, v2, v3, v4 = self.Integers(0, 10, -9, 2 ** 10)
        self.assertFalse(v1)
        self.assertFalse(bool(v1))
        self.failUnless(v2)
        self.failUnless(bool(v2))
        self.failUnless(v3)
        self.failUnless(v4)

    def test_is_negative(self):
        v1, v2, v3, v4, v5 = self.Integers(-3 ** 100, -3, 0, 3, 3**100)
        self.failUnless(v1.is_negative())
        self.failUnless(v2.is_negative())
        self.failIf(v4.is_negative())
        self.failIf(v5.is_negative())

    def test_addition(self):
        # Test Integer+Integer and Integer+int
        v1, v2, v3 = self.Integers(7, 90, -7)
        self.failUnless(isinstance(v1 + v2, self.Integer))
        self.assertEqual(v1 + v2, 97)
        self.assertEqual(v1 + 90, 97)
        self.assertEqual(v1 + v3, 0)
        self.assertEqual(v1 + (-7), 0)
        self.assertEqual(v1 + 2 ** 10, 2 ** 10 + 7)

    def test_subtraction(self):
        # Test Integer-Integer and Integer-int
        v1, v2, v3 = self.Integers(7, 90, -7)
        self.failUnless(isinstance(v1 - v2, self.Integer))
        self.assertEqual(v2 - v1, 83)
        self.assertEqual(v2 - 7, 83)
        self.assertEqual(v2 - v3, 97)
        self.assertEqual(v1 - (-7), 14)
        self.assertEqual(v1 - 2 ** 10, 7 - 2 ** 10)

    def test_multiplication(self):
        # Test Integer-Integer and Integer-int
        v1, v2, v3, v4 = self.Integers(4, 5, -2, 2 ** 10)
        self.failUnless(isinstance(v1 * v2, self.Integer))
        self.assertEqual(v1 * v2, 20)
        self.assertEqual(v1 * 5, 20)
        self.assertEqual(v1 * -2, -8)
        self.assertEqual(v1 * 2 ** 10, 4 * (2 ** 10))

    def test_floor_div(self):
        v1, v2, v3 = self.Integers(3, 8, 2 ** 80)
        self.failUnless(isinstance(v1 // v2, self.Integer))
        self.assertEqual(v2 // v1, 2)
        self.assertEqual(v2 // 3, 2)
        self.assertEqual(v2 // -3, -3)
        self.assertEqual(v3 // 2 ** 79, 2)
        self.assertRaises(ZeroDivisionError, lambda: v1 // 0)

    def test_remainder(self):
        # Test Integer%Integer and Integer%int
        v1, v2, v3 = self.Integers(23, 5, -4)
        self.failUnless(isinstance(v1 % v2, self.Integer))
        self.assertEqual(v1 % v2, 3)
        self.assertEqual(v1 % 5, 3)
        self.assertEqual(v3 % 5, 1)
        self.assertEqual(v1 % 2 ** 10, 23)
        self.assertRaises(ZeroDivisionError, lambda: v1 % 0)
        self.assertRaises(ValueError, lambda: v1 % -6)

    def test_simple_exponentiation(self):
        v1, v2, v3 = self.Integers(4, 3, -2)
        self.failUnless(isinstance(v1 ** v2, self.Integer))
        self.assertEqual(v1 ** v2, 64)
        self.assertEqual(pow(v1, v2), 64)
        self.assertEqual(v1 ** 3, 64)
        self.assertEqual(pow(v1, 3), 64)
        self.assertEqual(v3 ** 2, 4)
        self.assertEqual(v3 ** 3, -8)

        self.assertRaises(ValueError, pow, v1, -3)

    def test_modular_exponentiation(self):
        v1, v2, v3 = self.Integers(23, 5, 17)

        self.failUnless(isinstance(pow(v1, v2, v3), self.Integer))
        self.assertEqual(pow(v1, v2, v3), 7)
        self.assertEqual(pow(v1, 5,  v3), 7)
        self.assertEqual(pow(v1, v2, 17), 7)
        self.assertEqual(pow(v1, 5,  17), 7)
        self.assertEqual(pow(v1, 0,  17), 1)
        self.assertEqual(pow(v1, 1,  2 ** 80), 23)
        self.assertEqual(pow(v1, 2 ** 80,  89298), 17689)

        self.assertRaises(ZeroDivisionError, pow, v1, 5, 0)
        self.assertRaises(ValueError, pow, v1, 5, -4)
        self.assertRaises(ValueError, pow, v1, -3, 8)

    def test_inplace_exponentiation(self):
        v1 = self.Integer(4)
        v1.inplace_pow(2)
        self.assertEqual(v1, 16)

        v1 = self.Integer(4)
        v1.inplace_pow(2, 15)
        self.assertEqual(v1, 1)

    def test_abs(self):
        v1, v2, v3, v4, v5 = self.Integers(-2 ** 100, -2, 0, 2, 2 ** 100)
        self.assertEqual(abs(v1), 2 ** 100)
        self.assertEqual(abs(v2), 2)
        self.assertEqual(abs(v3), 0)
        self.assertEqual(abs(v4), 2)
        self.assertEqual(abs(v5), 2 ** 100)

    def test_sqrt(self):
        v1, v2, v3, v4 = self.Integers(-2, 0, 49, 10**100)

        self.assertRaises(ValueError, v1.sqrt)
        self.assertEqual(v2.sqrt(), 0)
        self.assertEqual(v3.sqrt(), 7)
        self.assertEqual(v4.sqrt(), 10**50)

    def test_sqrt_module(self):

        # Invalid modulus (non positive)
        self.assertRaises(ValueError, self.Integer(5).sqrt, 0)
        self.assertRaises(ValueError, self.Integer(5).sqrt, -1)

        # Simple cases
        assert self.Integer(0).sqrt(5) == 0
        assert self.Integer(1).sqrt(5) in (1, 4)

        # Test with all quadratic residues in several fields
        for p in (11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53):
            for i in range(0, p):
                square = i**2 % p
                res = self.Integer(square).sqrt(p)
                assert res in (i, p - i)

        # 2 is a non-quadratic reside in Z_11
        self.assertRaises(ValueError, self.Integer(2).sqrt, 11)
        
        # 10 is not a prime
        self.assertRaises(ValueError, self.Integer(4).sqrt, 10)

        # 5 is square residue of 4 and 7
        assert self.Integer(5 - 11).sqrt(11) in (4, 7)
        assert self.Integer(5 + 11).sqrt(11) in (4, 7)

    def test_in_place_add(self):
        v1, v2 = self.Integers(10, 20)

        v1 += v2
        self.assertEqual(v1, 30)
        v1 += 10
        self.assertEqual(v1, 40)
        v1 += -1
        self.assertEqual(v1, 39)
        v1 += 2 ** 1000
        self.assertEqual(v1, 39 + 2 ** 1000)

    def test_in_place_sub(self):
        v1, v2 = self.Integers(10, 20)