- Modify dart_api.h to be a proper C API.

runtime/vm/dart_api_impl_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.
 
 #include "include/dart_api.h"
 #include "bin/builtin.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
@@ skipping 782 matching lines @@
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_IsUnhandledExceptionError(result));
 
   result = Dart_ListSetAt(list_access_test_obj, 0, Dart_NewInteger(42));
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_IsUnhandledExceptionError(result));
 }
 
 
 TEST_CASE(TypedDataAccess) {
-  EXPECT_EQ(kInvalid, Dart_GetTypeOfTypedData(Dart_True()));
-  EXPECT_EQ(kInvalid, Dart_GetTypeOfExternalTypedData(Dart_False()));
-  Dart_Handle byte_array1 = Dart_NewTypedData(kUint8, 10);
+  EXPECT_EQ(Dart_TypedData_kInvalid,
+            Dart_GetTypeOfTypedData(Dart_True()));
+  EXPECT_EQ(Dart_TypedData_kInvalid,
+            Dart_GetTypeOfExternalTypedData(Dart_False()));
+  Dart_Handle byte_array1 = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
   EXPECT_VALID(byte_array1);
-  EXPECT_EQ(kUint8, Dart_GetTypeOfTypedData(byte_array1));
-  EXPECT_EQ(kInvalid, Dart_GetTypeOfExternalTypedData(byte_array1));
+  EXPECT_EQ(Dart_TypedData_kUint8,
+            Dart_GetTypeOfTypedData(byte_array1));
+  EXPECT_EQ(Dart_TypedData_kInvalid,
+            Dart_GetTypeOfExternalTypedData(byte_array1));
   EXPECT(Dart_IsList(byte_array1));
 
   intptr_t length = 0;
   Dart_Handle result = Dart_ListLength(byte_array1, &length);
   EXPECT_VALID(result);
   EXPECT_EQ(10, length);
 
   result = Dart_ListSetAt(byte_array1, -1, Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
 
   result = Dart_ListSetAt(byte_array1, 10, Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
 
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
     EXPECT_VALID(Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 1)));
   }
   for (intptr_t i = 0; i < 10; ++i) {
     // Get through the List API.
     Dart_Handle integer_obj = Dart_ListGetAt(byte_array1, i);
     EXPECT_VALID(integer_obj);
     int64_t int64_t_value = -1;
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(i + 1, int64_t_value);
   }
 
-  Dart_Handle byte_array2 = Dart_NewTypedData(kUint8, 10);
+  Dart_Handle byte_array2 = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
   bool is_equal = false;
   Dart_ObjectEquals(byte_array1, byte_array2, &is_equal);
   EXPECT(!is_equal);
 
   // Set through the List API.
   for (intptr_t i = 0; i < 10; ++i) {
     result = Dart_ListSetAt(byte_array1, i, Dart_NewInteger(i + 2));
     EXPECT_VALID(result);
     result = Dart_ListSetAt(byte_array2, i, Dart_NewInteger(i + 2));
     EXPECT_VALID(result);
@@ skipping 19 matching lines @@
     EXPECT_VALID(Dart_IntegerToInt64(integer_obj, &int64_t_value));
     EXPECT_EQ(10 - i, int64_t_value);
   }
 }
 
 
 static int kLength = 16;
 
 static void ByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
-  Dart_Handle byte_data = Dart_NewTypedData(kByteData, kLength);
+  Dart_Handle byte_data = Dart_NewTypedData(Dart_TypedData_kByteData, kLength);
   EXPECT_VALID(byte_data);
-  EXPECT_EQ(kByteData, Dart_GetTypeOfTypedData(byte_data));
+  EXPECT_EQ(Dart_TypedData_kByteData, Dart_GetTypeOfTypedData(byte_data));
   Dart_SetReturnValue(args, byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ByteDataNativeResolver(Dart_Handle name,
                                                   int arg_count) {
   return &ByteDataNativeFunction;
 }
 
@@ skipping 34 matching lines @@
 
 
 static const intptr_t kExtLength = 16;
 static int8_t data[kExtLength] = { 0x41, 0x42, 0x41, 0x42,
                                    0x41, 0x42, 0x41, 0x42,
                                    0x41, 0x42, 0x41, 0x42,
                                    0x41, 0x42, 0x41, 0x42, };
 
 static void ExternalByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
-  Dart_Handle external_byte_data = Dart_NewExternalTypedData(kByteData,
-                                                             data,
-                                                             16);
+  Dart_Handle external_byte_data = Dart_NewExternalTypedData(
+      Dart_TypedData_kByteData, data, 16);
   EXPECT_VALID(external_byte_data);
-  EXPECT_EQ(kByteData, Dart_GetTypeOfTypedData(external_byte_data));
+  EXPECT_EQ(Dart_TypedData_kByteData,
+            Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalByteDataNativeResolver(Dart_Handle name,
                                                           int arg_count) {
   return &ExternalByteDataNativeFunction;
 }
 
@@ skipping 40 matching lines @@
 
   for (intptr_t i = 0; i < kExtLength; i+=2) {
     EXPECT_EQ(0x24, data[i]);
     EXPECT_EQ(0x28, data[i+1]);
   }
 }
 
 
 TEST_CASE(TypedDataDirectAccess) {
   Dart_Handle str = Dart_NewStringFromCString("junk");
-  Dart_Handle byte_array = Dart_NewTypedData(kUint8, 10);
+  Dart_Handle byte_array = Dart_NewTypedData(Dart_TypedData_kUint8, 10);
   EXPECT_VALID(byte_array);
   Dart_Handle result;
   result = Dart_TypedDataAcquireData(byte_array, NULL, NULL, NULL);
   EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'type'"
                        " to be non-null.");
   Dart_TypedData_Type type;
   result = Dart_TypedDataAcquireData(byte_array, &type, NULL, NULL);
   EXPECT_ERROR(result, "Dart_TypedDataAcquireData expects argument 'data'"
                        " to be non-null.");
   void* data;
@@ skipping 83 matching lines @@
       "  var a = new Int8List(10);"
       "  return a;"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Test with an regular typed data object.
   Dart_Handle list_access_test_obj;
   list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(list_access_test_obj);
-  TestDirectAccess(lib, list_access_test_obj, kInt8);
+  TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kInt8);
 
   // Test with an external typed data object.
   uint8_t data[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   intptr_t data_length = ARRAY_SIZE(data);
   Dart_Handle ext_list_access_test_obj;
-  ext_list_access_test_obj = Dart_NewExternalTypedData(kUint8,
+  ext_list_access_test_obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8,
                                                        data, data_length);
   EXPECT_VALID(ext_list_access_test_obj);
-  TestDirectAccess(lib, ext_list_access_test_obj, kUint8);
+  TestDirectAccess(lib, ext_list_access_test_obj, Dart_TypedData_kUint8);
 }
 
 
 TEST_CASE(TypedDataViewDirectAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
@@ skipping 18 matching lines @@
       "  var view = new Int8List.view(a.buffer, 50, 10);"
       "  return view;"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Test with a typed data view object.
   Dart_Handle list_access_test_obj;
   list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(list_access_test_obj);
-  TestDirectAccess(lib, list_access_test_obj, kInt8);
+  TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kInt8);
 }
 
 
 TEST_CASE(ByteDataDirectAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
       "      throw 'not equal. expected: $a, got: $b';\n"
@@ skipping 18 matching lines @@
       "  var view = new ByteData.view(a.buffer, 50, 10);"
       "  return view;"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Test with a typed data view object.
   Dart_Handle list_access_test_obj;
   list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(list_access_test_obj);
-  TestDirectAccess(lib, list_access_test_obj, kByteData);
+  TestDirectAccess(lib, list_access_test_obj, Dart_TypedData_kByteData);
 }
 
 
 static void ExternalTypedDataAccessTests(Dart_Handle obj,
                                          Dart_TypedData_Type expected_type,
                                          uint8_t data[],
                                          intptr_t data_length) {
   EXPECT_VALID(obj);
   EXPECT_EQ(expected_type, Dart_GetTypeOfExternalTypedData(obj));
   EXPECT(Dart_IsList(obj));
@@ skipping 44 matching lines @@
   for (intptr_t i = 0; i < data_length; ++i) {
     EXPECT_EQ(33 * i, data[i]);
   }
 }
 
 
 TEST_CASE(ExternalTypedDataAccess) {
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalTypedData(kUint8, data, data_length);
-  ExternalTypedDataAccessTests(obj, kUint8, data, data_length);
+  Dart_Handle obj = Dart_NewExternalTypedData(
+      Dart_TypedData_kUint8, data, data_length);
+  ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8, data, data_length);
 }
 
 
 TEST_CASE(ExternalClampedTypedDataAccess) {
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped, data, data_length);
-  ExternalTypedDataAccessTests(obj, kUint8Clamped, data, data_length);
+  Dart_Handle obj = Dart_NewExternalTypedData(
+      Dart_TypedData_kUint8Clamped, data, data_length);
+  ExternalTypedDataAccessTests(obj, Dart_TypedData_kUint8Clamped,
+                               data, data_length);
 }
 
 
 TEST_CASE(ExternalUint8ClampedArrayAccess) {
     const char* kScriptChars =
       "testClamped(List a) {\n"
       "  if (a[1] != 11) return false;\n"
       "  a[1] = 3;\n"
       "  if (a[1] != 3) return false;\n"
       "  a[1] = -12;\n"
       "  if (a[1] != 0) return false;\n"
       "  a[1] = 1200;\n"
       "  if (a[1] != 255) return false;\n"
       "  return true;\n"
       "}\n";
 
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
-  Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped,
+  Dart_Handle obj = Dart_NewExternalTypedData(Dart_TypedData_kUint8Clamped,
                                               data, data_length);
   EXPECT_VALID(obj);
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle args[1];
   args[0] = obj;
   result = Dart_Invoke(lib, NewString("testClamped"), 1, args);
 
   // Check that result is true.
@@ skipping 12 matching lines @@
   *static_cast<int*>(peer) = 42;
 }
 
 
 TEST_CASE(ExternalTypedDataCallback) {
   int peer = 0;
   {
     Dart_EnterScope();
     uint8_t data[] = { 1, 2, 3, 4 };
     Dart_Handle obj = Dart_NewExternalTypedData(
-        kUint8,
+        Dart_TypedData_kUint8,
         data,
         ARRAY_SIZE(data));
     Dart_NewWeakPersistentHandle(obj, &peer, ExternalTypedDataFinalizer);
     EXPECT_VALID(obj);
     Dart_ExitScope();
   }
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(peer == 42);
 }
 
 
 static void CheckFloat32x4Data(Dart_Handle obj) {
   void* raw_data = NULL;
   intptr_t len;
   Dart_TypedData_Type type;
   EXPECT_VALID(Dart_TypedDataAcquireData(obj, &type, &raw_data, &len));
-  EXPECT_EQ(kFloat32x4, type);
+  EXPECT_EQ(Dart_TypedData_kFloat32x4, type);
   EXPECT_EQ(len, 10);
   float* float_data = reinterpret_cast<float*>(raw_data);
   for (int i = 0; i < len * 4; i++) {
     EXPECT_EQ(0.0, float_data[i]);
   }
   EXPECT_VALID(Dart_TypedDataReleaseData(obj));
 }
 
 
 TEST_CASE(Float32x4List) {
     const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "Float32x4List float32x4() {\n"
       "  return new Float32x4List(10);\n"
       "}\n";
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   Dart_Handle obj = Dart_Invoke(lib, NewString("float32x4"), 0, NULL);
   EXPECT_VALID(obj);
   CheckFloat32x4Data(obj);
 
-  obj = Dart_NewTypedData(kFloat32x4, 10);
+  obj = Dart_NewTypedData(Dart_TypedData_kFloat32x4, 10);
   EXPECT_VALID(obj);
   CheckFloat32x4Data(obj);
 
   int peer = 0;
   float data[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
   // Push a scope so that we can collect the local handle created as part of
   // Dart_NewExternalTypedData.
   Dart_EnterScope();
   {
-    Dart_Handle lcl = Dart_NewExternalTypedData(kFloat32x4, data, 10);
+    Dart_Handle lcl = Dart_NewExternalTypedData(
+        Dart_TypedData_kFloat32x4, data, 10);
     Dart_NewWeakPersistentHandle(lcl, &peer, ExternalTypedDataFinalizer);
     CheckFloat32x4Data(lcl);
   }
   Dart_ExitScope();
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(peer == 42);
 }
 
 
 // Unit test for entering a scope, creating a local handle and exiting
@@ skipping 3879 matching lines @@
 
   // Check that error is returned if null is passed as a class argument.
   result = Dart_ObjectIsType(null, null, &is_instance);
   EXPECT(Dart_IsError(result));
 }
 
 
 static Dart_Handle library_handler(Dart_LibraryTag tag,
                                    Dart_Handle library,
                                    Dart_Handle url) {
-  if (tag == kCanonicalizeUrl) {
+  if (tag == Dart_kCanonicalizeUrl) {
     return url;
   }
   return Api::Success();
 }
 
 
 TEST_CASE(LoadScript) {
   const char* kScriptChars =
       "main() {"
       "  return 12345;"
@@ skipping 79 matching lines @@
   EXPECT_STREQ(TestCase::url(), name_cstr);
 }
 
 
 static int index = 0;
 
 
 static Dart_Handle import_library_handler(Dart_LibraryTag tag,
                                           Dart_Handle library,
                                           Dart_Handle url) {
-  if (tag == kCanonicalizeUrl) {
+  if (tag == Dart_kCanonicalizeUrl) {
     return url;
   }
   EXPECT(Dart_IsString(url));
   const char* cstr = NULL;
   EXPECT_VALID(Dart_StringToCString(url, &cstr));
   switch (index) {
     case 0:
       EXPECT_STREQ("./weird.dart", cstr);
       break;
     case 1:
@@ skipping 1038 matching lines @@
   result = Dart_Invoke(result, NewString("main"), 0, NULL);
   EXPECT_VALID(result);
 }
 
 
 void NewNativePort_send123(Dart_Port dest_port_id,
                            Dart_Port reply_port_id,
                            Dart_CObject *message) {
   // Gets a null message.
   EXPECT_NOTNULL(message);
-  EXPECT_EQ(Dart_CObject::kNull, message->type);
+  EXPECT_EQ(Dart_CObject_kNull, message->type);
 
   // Post integer value.
   Dart_CObject* response =
       reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(sizeof(Dart_CObject)));
-  response->type = Dart_CObject::kInt32;
+  response->type = Dart_CObject_kInt32;
   response->value.as_int32 = 123;
   Dart_PostCObject(reply_port_id, response);
 }
 
 
 void NewNativePort_send321(Dart_Port dest_port_id,
                            Dart_Port reply_port_id,
                            Dart_CObject* message) {
   // Gets a null message.
   EXPECT_NOTNULL(message);
-  EXPECT_EQ(Dart_CObject::kNull, message->type);
+  EXPECT_EQ(Dart_CObject_kNull, message->type);
 
   // Post integer value.
   Dart_CObject* response =
       reinterpret_cast<Dart_CObject*>(Dart_ScopeAllocate(sizeof(Dart_CObject)));
-  response->type = Dart_CObject::kInt32;
+  response->type = Dart_CObject_kInt32;
   response->value.as_int32 = 321;
   Dart_PostCObject(reply_port_id, response);
 }
 
 
 UNIT_TEST_CASE(NewNativePort) {
   // Create a port with a bogus handler.
   Dart_Port error_port = Dart_NewNativePort("Foo", NULL, true);
   EXPECT_EQ(ILLEGAL_PORT, error_port);
 
@@ skipping 1421 matching lines @@
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(8, value);
 }
 
 }  // namespace dart