@@ -108,10 +108,19 @@ def testUnsetVar(self):
108108 self .assertIn (
109109 'No value with name "var_bool" found in Activation' , res .value ()
110110 )
111+ self .assertEqual (res , self ._eval ("var_bool" , {}))
112+ self .assertNotEqual (res , res .value ())
113+ self .assertNotEqual (res .value (), res )
114+ self .assertNotEqual (res , self ._eval ("var_str" , {"var_str" : res .value ()}))
115+ self .assertFalse (res .equals (res ))
116+ self .assertFalse (res .equals (self ._eval ("var_bool" , {})))
117+ self .assertFalse (res .equals (self ._eval ("true" )))
111118
112119 def testEvalNull (self ):
113120 res : cel .Value = self ._eval ("null" , expected_return_type = cel .Type .NULL )
114121 self .assertEqual (res .type (), cel .Type .NULL )
122+ self .assertEqual (res , None ) # pylint: disable=g-generic-assert
123+ self .assertEqual (None , res ) # pylint: disable=g-generic-assert
115124 self .assertIsNone (res .value ())
116125 self .assertIsNone (res .plain_value ())
117126
@@ -129,9 +138,23 @@ def testEvalNull(self):
129138 def testEvalBool (self ):
130139 res : cel .Value = self ._eval ("true" , expected_return_type = cel .Type .BOOL )
131140 self .assertEqual (res .type (), cel .Type .BOOL )
141+ self .assertEqual (res , True ) # pylint: disable=g-generic-assert
142+ self .assertEqual (True , res ) # pylint: disable=g-generic-assert
143+ self .assertEqual (res , 1 )
144+ self .assertEqual (1 , res )
145+ self .assertEqual (res , self ._eval ("1" ))
146+ self .assertTrue (res .equals (self ._eval ("true" )))
147+ self .assertFalse (res .equals (self ._eval ("1" )))
148+ with self .assertRaises (TypeError ):
149+ non_cel_val : Any = True
150+ res .equals (non_cel_val )
132151 self .assertEqual (res .value (), True )
133152 self .assertEqual (res .plain_value (), True )
134153 res = self ._eval ("false" )
154+ self .assertEqual (res , False ) # pylint: disable=g-generic-assert
155+ self .assertEqual (res , 0 )
156+ self .assertEqual (self ._eval ("[false]" ), [0 ])
157+ self .assertFalse (self ._eval ("[false]" ).equals (self ._eval ("[0]" )))
135158 self .assertEqual (res .value (), False )
136159 res = self ._eval ("1 + 1 == 2" )
137160 self .assertEqual (res .value (), True )
@@ -147,6 +170,10 @@ def testEvalBool(self):
147170 def testEvalInt64 (self ):
148171 res : cel .Value = self ._eval ("42" , expected_return_type = cel .Type .INT )
149172 self .assertEqual (res .type (), cel .Type .INT )
173+ self .assertEqual (res , 42 )
174+ self .assertEqual (42 , res )
175+ self .assertNotEqual (res , 43 )
176+ self .assertEqual (res , self ._eval ("40 + 2" ))
150177 self .assertEqual (res .value (), 42 )
151178 self .assertEqual (res .plain_value (), 42 )
152179 res = self ._eval ("1000 + 200 + 30 + 4" )
@@ -369,12 +396,45 @@ def testEvalList(self):
369396 "[1, 'CEL', true]" , expected_return_type = cel .Type .LIST
370397 )
371398 self .assertEqual (res .type (), cel .Type .LIST )
399+ self .assertEqual (res , [1 , "CEL" , True ])
400+ self .assertEqual ([1 , "CEL" , True ], res )
401+ self .assertNotEqual (res , [1 , "CEL" , False ])
402+ self .assertEqual (res .value (), [1 , "CEL" , True ])
403+ self .assertEqual ([1 , "CEL" , True ], res .value ())
404+ self .assertNotEqual (res .value (), [1 , "CEL" , False ])
372405 self .assertEqual ([item .value () for item in res .value ()], [1 , "CEL" , True ])
373406 self .assertEqual (res .plain_value (), [1 , "CEL" , True ])
374407
408+ self .assertEqual (
409+ self ._eval ("[[1, 2], [3]]" ),
410+ [[1 , 2 ], [3 ]],
411+ )
412+ self .assertEqual (
413+ self ._eval ("[[1, 2], [3]]" ).value (),
414+ [[1 , 2 ], [3 ]],
415+ )
416+ self .assertEqual (
417+ self ._eval ("[1, 2]" ),
418+ self ._eval ("[1, 2]" ),
419+ )
420+ self .assertEqual (
421+ self ._eval ("[1, 2]" ).value (),
422+ self ._eval ("[1, 2]" ).value (),
423+ )
424+ self .assertNotEqual (
425+ self ._eval ("[1, 2]" ),
426+ self ._eval ("[1, 3]" ),
427+ )
428+ self .assertNotEqual (
429+ self ._eval ("[1, 2]" ).value (),
430+ self ._eval ("[1, 3]" ).value (),
431+ )
432+
375433 res = self ._eval ("[1]" , expected_return_type = cel .Type .List (cel .Type .INT ))
376434 self .assertEqual (res .type (), cel .Type .LIST )
377- self .assertEqual (res .value ()[0 ].value (), 1 )
435+ self .assertEqual (res , [1 ])
436+ self .assertEqual (res .value (), [1 ])
437+ self .assertEqual (res .value ()[0 ], 1 )
378438
379439 res = self ._eval (
380440 "["
@@ -406,6 +466,31 @@ def testEvalList(self):
406466 self .assertEqual (res_list [1 ].type (), cel .Type .DOUBLE )
407467 self .assertAlmostEqual (res_list [1 ].value (), 3.14 , places = 3 )
408468
469+ # An Any with an unknown type_url succeeds at field selection (producing a
470+ # valid LIST of _CelListItemAccessors) and only fails when the element is
471+ # lazily unpacked, exercising PyCelListItemAccessor::IsError() so error
472+ # elements match identical errors but not plain str or STRING values.
473+ bad_msg = test_all_types_pb .TestAllTypes ()
474+ bad_msg .repeated_any .add ().type_url = (
475+ "type.googleapis.com/nonexistent.Message"
476+ )
477+ bad_list_item = self ._eval (
478+ "var_msg.repeated_any" , {"var_msg" : bad_msg }
479+ ).value ()[0 ]
480+ self .assertEqual (bad_list_item .type (), cel .Type .ERROR )
481+ self .assertEqual (
482+ bad_list_item ,
483+ self ._eval ("var_msg.repeated_any" , {"var_msg" : bad_msg }).value ()[0 ],
484+ )
485+ self .assertNotEqual (bad_list_item , bad_list_item .value ())
486+ self .assertNotEqual (bad_list_item .value (), bad_list_item )
487+ self .assertNotEqual (
488+ bad_list_item ,
489+ self ._eval ("var_str" , {"var_str" : bad_list_item .value ()}),
490+ )
491+ self .assertFalse (bad_list_item .equals (bad_list_item ))
492+ self .assertTrue (self ._eval ("[1, 2]" ).value ()[0 ].equals (self ._eval ("1u" )))
493+
409494 def testEvalList_unexpectedType (self ):
410495 res = self ._eval ("var_string_list" , {"var_string_list" : ["pi" , 3.14 ]})
411496 self .assertEqual (res .type (), cel .Type .ERROR )
@@ -421,11 +506,25 @@ def testEvalMap(self):
421506 expected_return_type = cel .Type .Map (cel .Type .INT , cel .Type .STRING ),
422507 )
423508 self .assertEqual (res .type (), cel .Type .MAP )
509+ self .assertEqual (res , {777 : "CEL" , 42 : "Python" })
510+ self .assertEqual ({777 : "CEL" , 42 : "Python" }, res )
511+ self .assertNotEqual (res , {777 : "CEL" , 42 : "C++" })
424512 res_map = res .value ()
425513 self .assertLen (res_map , 2 )
426- self .assertEqual (res_map [777 ].value (), "CEL" )
427- self .assertEqual (res_map [42 ].value (), "Python" )
514+ self .assertEqual (res_map , {777 : "CEL" , 42 : "Python" })
515+ self .assertEqual ({777 : "CEL" , 42 : "Python" }, res_map )
516+ self .assertNotEqual (res_map , {777 : "CEL" , 42 : "C++" })
517+ self .assertEqual (res_map [777 ], "CEL" )
518+ self .assertEqual (res_map [42 ], "Python" )
428519 self .assertEqual (res .plain_value (), {777 : "CEL" , 42 : "Python" })
520+ self .assertEqual (
521+ self ._eval ("{'a': [1, 2]}" ),
522+ {"a" : [1 , 2 ]},
523+ )
524+ self .assertEqual (
525+ self ._eval ("{'a': [1, 2]}" ).value (),
526+ {"a" : [1 , 2 ]},
527+ )
429528
430529 res = self ._eval (
431530 "var_int_map" ,
@@ -439,6 +538,33 @@ def testEvalMap(self):
439538 self .assertEqual (res_map [42 ].value (), "Python" )
440539 self .assertEqual (res .plain_value (), {777 : "CEL" , 42 : "Python" })
441540
541+ # An Any with an unknown type_url succeeds at field selection (producing a
542+ # valid MAP whose entries are _CelMapItemAccessors) and only fails when the
543+ # entry is lazily unpacked, exercising PyCelMapItemAccessor::IsError() so
544+ # error entries match identical errors but not plain str or STRING values.
545+ bad_msg = test_all_types_pb .TestAllTypes ()
546+ bad_msg .map_int64_any [1 ].type_url = (
547+ "type.googleapis.com/nonexistent.Message"
548+ )
549+ bad_map_item = self ._eval (
550+ "var_msg.map_int64_any" , {"var_msg" : bad_msg }
551+ ).value ()[1 ]
552+ self .assertEqual (bad_map_item .type (), cel .Type .ERROR )
553+ self .assertEqual (
554+ bad_map_item ,
555+ self ._eval ("var_msg.map_int64_any" , {"var_msg" : bad_msg }).value ()[1 ],
556+ )
557+ self .assertNotEqual (bad_map_item , bad_map_item .value ())
558+ self .assertNotEqual (bad_map_item .value (), bad_map_item )
559+ self .assertNotEqual (
560+ bad_map_item ,
561+ self ._eval ("var_str" , {"var_str" : bad_map_item .value ()}),
562+ )
563+ self .assertFalse (bad_map_item .equals (bad_map_item ))
564+ self .assertTrue (
565+ self ._eval ("{'a': 1}" ).value ()["a" ].equals (self ._eval ("1.0" ))
566+ )
567+
442568 res = self ._eval (
443569 "var_string_map" , {"var_string_map" : {"CEL" : True , "Python" : 42 }}
444570 )
@@ -660,6 +786,9 @@ def testTypeType(self):
660786 "type(1)" , expected_return_type = cel .Type .Type (cel .Type .INT )
661787 )
662788 self .assertEqual (res .type (), cel .Type .TYPE )
789+ self .assertEqual (res , cel .Type .INT )
790+ self .assertEqual (cel .Type .INT , res )
791+ self .assertNotEqual (res , 1 )
663792 self .assertEqual (res .value (), cel .Type .INT )
664793
665794 res = self ._eval (
@@ -703,6 +832,54 @@ def testTypeType(self):
703832 )
704833 self .assertEqual (res .value (), cel .Type .INT )
705834
835+ def testCelEquals (self ):
836+ # Cross-numeric comparisons work in both == and equals().
837+ val_int = self ._eval ("1" )
838+ val_uint = self ._eval ("1u" )
839+ val_double = self ._eval ("1.0" )
840+ self .assertEqual (val_int , val_uint )
841+ self .assertEqual (val_int , val_double )
842+ self .assertEqual (val_uint , val_double )
843+ self .assertTrue (val_int .equals (val_uint ))
844+ self .assertTrue (val_int .equals (val_double ))
845+ self .assertTrue (val_uint .equals (val_double ))
846+ self .assertFalse (self ._eval ("-1" ).equals (val_uint ))
847+
848+ # Python == compares int vs float exactly, whereas CEL equals() casts
849+ # int64/uint64 to double (matching CEL's in-language ==).
850+ exact_int = self ._eval ("9007199254740993" ) # (1 << 53) + 1
851+ approx_double = self ._eval ("9007199254740992.0" ) # float(1 << 53)
852+ self .assertNotEqual (exact_int , approx_double )
853+ self .assertTrue (exact_int .equals (approx_double ))
854+
855+ # NaN is unequal to itself in both Python and CEL.
856+ nan_val = self ._eval ("0.0 / 0.0" )
857+ self .assertNotEqual (nan_val , nan_val )
858+ self .assertFalse (nan_val .equals (nan_val ))
859+
860+ # Containers apply CEL equality recursively to elements/values.
861+ self .assertTrue (self ._eval ("[1, 2]" ).equals (self ._eval ("[1u, 2.0]" )))
862+ self .assertTrue (self ._eval ("{'a': 1}" ).equals (self ._eval ("{'a': 1.0}" )))
863+ self .assertFalse (self ._eval ("[1, 2]" ).equals (self ._eval ("[1, 3]" )))
864+
865+ # Proto comparisons: == delegates to Python protobuf Message.__eq__ (raw
866+ # Any bytes), whereas equals() uses CEL MessageEquals (unpacks Any).
867+ msg1 = test_all_types_pb .TestAllTypes ()
868+ msg1 .single_any .Pack (
869+ test_all_types_pb .TestAllTypes (single_int32 = 1 , single_string = "a" )
870+ )
871+ msg2 = test_all_types_pb .TestAllTypes ()
872+ msg2 .single_any .type_url = msg1 .single_any .type_url
873+ msg2 .single_any .value = (
874+ test_all_types_pb .TestAllTypes (single_string = "a" ).SerializeToString ()
875+ + test_all_types_pb .TestAllTypes (single_int32 = 1 ).SerializeToString ()
876+ )
877+ cel_msg1 = self ._eval ("var_msg" , {"var_msg" : msg1 })
878+ cel_msg2 = self ._eval ("var_msg" , {"var_msg" : msg2 })
879+ self .assertEqual (cel_msg1 , msg1 )
880+ self .assertNotEqual (cel_msg1 , cel_msg2 )
881+ self .assertTrue (cel_msg1 .equals (cel_msg2 ))
882+
706883 def testTypeInitSignature (self ):
707884 self .assertEqual (cel .Type ("int" ), cel .Type .INT )
708885 self .assertEqual (cel .Type ("list<int>" ), cel .Type .List (cel .Type .INT ))
0 commit comments