#####################################################################################

#

#  Copyright (c) Microsoft Corporation. All rights reserved.

#

#  This source code is subject to terms and conditions of the Shared Source License

#  for IronPython. A copy of the license can be found in the License.html file

#  at the root of this distribution. If you can not locate the Shared Source License

#  for IronPython, please send an email to ironpy@microsoft.com.

#  By using this source code in any fashion, you are agreeing to be bound by

#  the terms of the Shared Source License for IronPython.

#

#  You must not remove this notice, or any other, from this software.

#

######################################################################################



from common import *

import testdata



if not is_cli: 

    import warnings

    warnings.filterwarnings("ignore",

                            r'complex divmod\(\), // and % are deprecated',

                            DeprecationWarning,

                            r'sbs_simple_ops$'

                           )



class oldstyle: 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "oldstyle(%s)" % self.value

    def __add__(self, other):           return self.value + other

    def __sub__(self, other):           return self.value - other

    def __mul__(self, other):           return self.value * other

    def __div__(self, other):           return self.value / other

    def __floordiv__(self, other):      return self.value // other

    def __mod__(self, other):           return self.value % other

    def __divmod__(self, other):        return divmod(self.value,  other)

    def __pow__(self, other):           return self.value ** other

    def __lshift__(self, other):        return self.value << other

    def __rshift__(self, other):        return self.value >> other

    def __and__(self, other):           return self.value & other

    def __xor__(self, other):           return self.value ^ other

    def __or__(self, other):            return self.value | other



class oldstyle_reflect: 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "oldstyle_reflect(%s)" % self.value

    def __radd__(self, other):          return other + self.value

    def __rsub__(self, other):          return other - self.value

    def __rmul__(self, other):          return other * self.value

    def __rdiv__(self, other):          return other / self.value

    def __rfloordiv__(self, other):     return other // self.value

    def __rmod__(self, other):          return other % self.value

    def __rdivmod__(self, other):       return divmod(other, self.value)

    def __rpow__(self, other):          return other ** self.value

    def __rlshift__(self, other):       return other << self.value

    def __rrshift__(self, other):       return other >> self.value

    def __rand__(self, other):          return self.value & other

    def __rxor__(self, other):          return self.value ^ other

    def __ror__(self, other):           return self.value | other

        

class oldstyle_inplace: 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "oldstyle_inplace(%s)" % self.value

    def __iadd__(self, other):          return self.value + other

    def __isub__(self, other):          return self.value - other

    def __imul__(self, other):          return self.value * other

    def __idiv__(self, other):          return self.value / other

    def __ifloordiv__(self, other):     return self.value // other

    def __imod__(self, other):          return self.value % other

    def __idivmod__(self, other):        return divmod(self.value,  other)

    def __ipow__(self, other):          return self.value ** other

    def __ilshift__(self, other):       return self.value << other

    def __irshift__(self, other):       return self.value >> other

    def __iand__(self, other):           return self.value & other

    def __ixor__(self, other):          return self.value ^ other

    def __ior__(self, other):           return self.value | other   



class oldstyle_notdefined: 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "oldstyle_notdefined(%s)" % self.value



class newstyle(object): 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "newstyle(%s)" % self.value

    def __add__(self, other):           return self.value + other

    def __sub__(self, other):           return self.value - other

    def __mul__(self, other):           return self.value * other

    def __div__(self, other):           return self.value / other

    def __floordiv__(self, other):      return self.value // other

    def __mod__(self, other):           return self.value % other

    def __divmod__(self, other):        return divmod(self.value,  other)

    def __pow__(self, other):           return self.value ** other

    def __lshift__(self, other):        return self.value << other

    def __rshift__(self, other):        return self.value >> other

    def __and__(self, other):           return self.value & other

    def __xor__(self, other):           return self.value ^ other

    def __or__(self, other):            return self.value | other



class newstyle_reflect(object): 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "newstyle_reflect(%s)" % self.value

    def __radd__(self, other):          return other + self.value

    def __rsub__(self, other):          return other - self.value

    def __rmul__(self, other):          return other * self.value

    def __rdiv__(self, other):          return other / self.value

    def __rfloordiv__(self, other):     return other // self.value

    def __rmod__(self, other):          return other % self.value

    def __rdivmod__(self, other):       return divmod(other, self.value)

    def __rpow__(self, other):          return other ** self.value

    def __rlshift__(self, other):       return other << self.value

    def __rrshift__(self, other):       return other >> self.value

    def __rand__(self, other):          return self.value & other

    def __rxor__(self, other):          return self.value ^ other

    def __ror__(self, other):           return self.value | other

        

class newstyle_inplace(object): 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "newstyle_inplace(%s)" % self.value

    def __iadd__(self, other):          return self.value + other

    def __isub__(self, other):          return self.value - other

    def __imul__(self, other):          return self.value * other

    def __idiv__(self, other):          return self.value / other

    def __ifloordiv__(self, other):     return self.value // other

    def __imod__(self, other):          return self.value % other

    def __idivmod__(self, other):        return divmod(self.value,  other)

    def __ipow__(self, other):          return self.value ** other

    def __ilshift__(self, other):       return self.value << other

    def __irshift__(self, other):       return self.value >> other

    def __iand__(self, other):           return self.value & other

    def __ixor__(self, other):          return self.value ^ other

    def __ior__(self, other):           return self.value | other   



class newstyle_notdefined(object): 

    def __init__(self, value):          self.value = value

    def __repr__(self):                 return "newstyle_notdefined(%s)" % self.value



import sys



class common(object):

    def normal(self, leftc, rightc):

        for a in leftc:

            for b in rightc:

                for op in ["+", "-", "*", "/", "//", "%", "**", "<<", ">>", "&", "^", "|"]:  

                    try:

                        printwith("case", a, op,  b, type(a), type(b))

                        printwithtype(eval("a %s b" % op))

                    except: 

                        printwith("same", sys.exc_type)

    

    def clone_list(self, l):

        l2 = []

        for x in l:

            if x is newstyle_inplace:

                l2.append(newstyle_inplace(x.value))

            elif x is oldstyle_inplace:

                l2.append(oldstyle_inplace(x.value))

            else :

                l2.append(x)

        return l2



    def inplace(self, leftc, rightc):

        rc = self.clone_list(rightc)

        for b in rc:

            for op in ["+", "-", "*", "//", "%", "**", "<<", ">>", "&", "^", "|"]:  

                lc = self.clone_list(leftc)

                for a in lc:

                    try:

                        line = "a %s= b" % op

                        printwith("case", "%s %s= %s" % (a, op, b), type(a), type(b))

                        exec line

                        printwithtype(a)

                    except: 

                        printwith("same", sys.exc_type)    



class ops_simple(common):

    def __init__(self):

        self.collection = testdata.merge_lists(

                [None], 

                testdata.list_bool,

                testdata.list_int,

                testdata.list_float,

                testdata.list_long[:-1],        # the last number is very long

                testdata.list_complex,



                testdata.list_myint,

                testdata.list_myfloat,

                testdata.list_mylong,

                testdata.list_mycomplex,

                testdata.get_Int64_Byte(),

                )



        self.collection_oldstyle            = [oldstyle(x)              for x in self.collection]

        self.collection_oldstyle_reflect    = [oldstyle_reflect(x)      for x in self.collection]

        self.collection_oldstyle_notdefined = [oldstyle_notdefined(x)   for x in self.collection]

        self.collection_newstyle            = [newstyle(x)              for x in self.collection]

        self.collection_newstyle_reflect    = [newstyle_reflect(x)      for x in self.collection]

        self.collection_newstyle_notdefined = [newstyle_notdefined(x)   for x in self.collection]



        self.collection_oldstyle_inplace    = [oldstyle_inplace(x)      for x in self.collection]

        self.collection_newstyle_inplace    = [newstyle_inplace(x)      for x in self.collection]



    def test_normal(self):              super(ops_simple, self).normal(self.collection, self.collection)



    def test_normal_oc_left(self):      super(ops_simple, self).normal(self.collection_oldstyle, self.collection)

    def test_normal_oc_right(self):     super(ops_simple, self).normal(self.collection, self.collection_oldstyle)



    def test_normal_nc_left(self):      super(ops_simple, self).normal(self.collection_newstyle, self.collection)

    def test_normal_nc_right(self):     super(ops_simple, self).normal(self.collection, self.collection_newstyle)



    def test_reflect_oc_right(self):    super(ops_simple, self).normal(self.collection, self.collection_oldstyle_reflect)

    def test_reflect_nc_right(self):    super(ops_simple, self).normal(self.collection, self.collection_newstyle_reflect)



    def test_oc_notdefined(self):       super(ops_simple, self).normal(self.collection_oldstyle_notdefined, self.collection)

    def test_nc_notdefined(self):       super(ops_simple, self).normal(self.collection_newstyle_notdefined, self.collection)



    def test_oc_notdefined_oc_reflect(self):       super(ops_simple, self).normal(self.collection_oldstyle_notdefined, self.collection_oldstyle_reflect)

    def test_nc_notdefined_nc_reflect(self):       super(ops_simple, self).normal(self.collection_newstyle_notdefined, self.collection_newstyle_reflect)



    def test_inplace(self):             super(ops_simple, self).inplace(self.collection, self.collection)

    def test_inplace_ol(self):          super(ops_simple, self).inplace(self.collection_oldstyle_inplace, self.collection)

    def test_inplace_nl(self):          super(ops_simple, self).inplace(self.collection_newstyle_inplace, self.collection)



runtests(ops_simple)