Instance equality

runtime/vm/object_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // TODO(zra): Remove when tests are ready to enable.
 #include "platform/globals.h"
 
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
@@ skipping 498 matching lines @@
     EXPECT_EQ(dbl_const, dbl2.value());
     EXPECT_EQ(dbl_const, dbl3.value());
     EXPECT_EQ(dbl1.raw(), dbl2.raw());
     EXPECT_EQ(dbl1.raw(), dbl3.raw());
   }
 
   {
     const double dbl_const = 2.0;
     const Double& dbl1 = Double::Handle(Double::New(dbl_const));
     const Double& dbl2 = Double::Handle(Double::New(dbl_const));
-    EXPECT(dbl1.Equals(dbl2));
+    EXPECT(dbl1.OperatorEquals(dbl2));
+    EXPECT(dbl1.IsIdenticalTo(dbl2));
+    EXPECT(dbl1.CanonicalizeEquals(dbl2));
     const Double& dbl3 = Double::Handle(Double::New(3.3));
-    EXPECT(!dbl1.Equals(dbl3));
-    EXPECT(!dbl1.Equals(Smi::Handle(Smi::New(3))));
-    EXPECT(!dbl1.Equals(Double::Handle()));
+    EXPECT(!dbl1.OperatorEquals(dbl3));
+    EXPECT(!dbl1.OperatorEquals(Smi::Handle(Smi::New(3))));
+    EXPECT(!dbl1.OperatorEquals(Double::Handle()));
+    const Double& nan0 = Double::Handle(Double::New(NAN));
+    EXPECT(nan0.IsIdenticalTo(nan0));
+    EXPECT(nan0.CanonicalizeEquals(nan0));
+    EXPECT(!nan0.OperatorEquals(nan0));
+    // TODO(18738): Test bitwise different NaNs after agreement on spec.
   }
   {
     const String& dbl_str0 = String::Handle(String::New("bla"));
     const Double& dbl0 = Double::Handle(Double::New(dbl_str0));
     EXPECT(dbl0.IsNull());
 
     const String& dbl_str1 = String::Handle(String::New("2.0"));
     const Double& dbl1 = Double::Handle(Double::New(dbl_str1));
     EXPECT_EQ(2.0, dbl1.value());
 
@@ skipping 1297 matching lines @@
   EXPECT_EQ(array.raw(), element.raw());
   element = array.At(1);
   EXPECT(element.IsNull());
   element = array.At(2);
   EXPECT_EQ(array.raw(), element.raw());
 
   Array& other_array = Array::Handle(Array::New(kArrayLen));
   other_array.SetAt(0, array);
   other_array.SetAt(2, array);
 
-  EXPECT(array.Equals(array));
-  EXPECT(array.Equals(other_array));
+  EXPECT(array.CanonicalizeEquals(array));
+  EXPECT(array.CanonicalizeEquals(other_array));
 
   other_array.SetAt(1, other_array);
-  EXPECT(!array.Equals(other_array));
+  EXPECT(!array.CanonicalizeEquals(other_array));
 
   other_array = Array::New(kArrayLen - 1);
   other_array.SetAt(0, array);
   other_array.SetAt(2, array);
-  EXPECT(!array.Equals(other_array));
+  EXPECT(!array.CanonicalizeEquals(other_array));
 
   EXPECT_EQ(0, Object::empty_array().Length());
 
   EXPECT_EQ(1, Object::zero_array().Length());
   element = Object::zero_array().At(0);
   EXPECT(Smi::Cast(element).IsZero());
 
   array.MakeImmutable();
   Object& obj = Object::Handle(array.raw());
   EXPECT(obj.IsArray());
@@ skipping 2150 matching lines @@
 };
 
 
 TEST_CASE(PrintJSON) {
   Heap* heap = Isolate::Current()->heap();
   heap->CollectAllGarbage();
   JSONTypeVerifier verifier;
   heap->IterateObjects(&verifier);
 }
 
+
+TEST_CASE(InstanceEquality) {
+  // Test that Instance::OperatorEquals can call a user-defined operator==.
+  const char* kScript =
+      "class A {\n"
+      "  bool operator==(A other) { return true; }\n"
+      "}\n"
+      "main() {\n"
+      "  A a = new A();\n"
+      "}";
+
+  Dart_Handle h_lib = TestCase::LoadTestScript(kScript, NULL);
+  EXPECT_VALID(h_lib);
+  Library& lib = Library::Handle();
+  lib ^= Api::UnwrapHandle(h_lib);
+  EXPECT(!lib.IsNull());
+  Dart_Handle result = Dart_Invoke(h_lib, NewString("main"), 0, NULL);
+  EXPECT_VALID(result);
+  const Class& clazz = Class::Handle(GetClass(lib, "A"));
+  EXPECT(!clazz.IsNull());
+  const Instance& a0 = Instance::Handle(Instance::New(clazz));
+  const Instance& a1 = Instance::Handle(Instance::New(clazz));
+  EXPECT(a0.raw() != a1.raw());
+  EXPECT(a0.OperatorEquals(a0));
+  EXPECT(a0.OperatorEquals(a1));
+  EXPECT(a0.IsIdenticalTo(a0));
+  EXPECT(!a0.IsIdenticalTo(a1));
+}
+
 }  // namespace dart