40 params.start_kernel_isolate =
true;
46 const char* kScriptChars =
70 params.start_kernel_isolate =
true;
72 bool was_called =
false;
74 code_observer.
data = &was_called;
76 uintptr_t
base, uintptr_t size) {
77 *
static_cast<bool*
>(observer->
data) =
true;
79 params.code_observer = &code_observer;
100 params.start_kernel_isolate =
true;
103 const char* options_1[] = {
"--old-gen-heap-size=3192",
104 "--new-gen-semi-max-size=32"};
107 EXPECT(FLAG_old_gen_heap_size == 3192);
108 EXPECT(FLAG_new_gen_semi_max_size == 32);
111 const char* options_2[] = {
"--old-gen-heap-size=16384",
112 "--new-gen-semi-max-size=16384"};
116 EXPECT(FLAG_old_gen_heap_size == 0);
119 EXPECT(FLAG_old_gen_heap_size == 16384);
120 EXPECT(FLAG_new_gen_semi_max_size == 16384);
124 const char* options_3[] = {
"--old-gen-heap-size=30720",
125 "--new-gen-semi-max-size=30720"};
129 EXPECT(FLAG_old_gen_heap_size == 0);
132 EXPECT(FLAG_old_gen_heap_size == 30720);
133 EXPECT(FLAG_new_gen_semi_max_size == 30720);
139 const char* kScriptChars =
149 EXPECT_EQ(42,
value);
160 : isolate_(isolate), monitor_(monitor), interrupted_(interrupted) {}
163 const char* kScriptChars =
180 *interrupted_ =
true;
193 bool interrupted =
false;
205 while (!interrupted) {
213 const char* kScriptChars =
214 "void testMain() {\n"
215 " throw new Exception(\"bad news\");\n"
234 EXPECT_STREQ(
ZONE_STR(
"Unhandled exception:\n"
235 "Exception: bad news\n"
236 "#0 testMain (%s:2:3)",
249 const char* kScriptChars =
250 "bar() => throw new Error();\n"
252 "testMain() => foo();\n";
263 intptr_t frame_count = 0;
266 EXPECT_EQ(3, frame_count);
270 intptr_t line_number = 0;
271 intptr_t column_number = 0;
272 const char* cstr =
"";
278 &line_number, &column_number);
281 EXPECT_STREQ(
"bar", cstr);
283 EXPECT_SUBSTRING(
"test-lib", cstr);
284 EXPECT_EQ(1, line_number);
285 EXPECT_EQ(10, column_number);
290 &line_number, &column_number);
293 EXPECT_STREQ(
"foo", cstr);
295 EXPECT_SUBSTRING(
"test-lib", cstr);
296 EXPECT_EQ(2, line_number);
297 EXPECT_EQ(10, column_number);
302 &line_number, &column_number);
305 EXPECT_STREQ(
"testMain", cstr);
307 EXPECT_SUBSTRING(
"test-lib", cstr);
308 EXPECT_EQ(3, line_number);
309 EXPECT_EQ(15, column_number);
319 const char* kScriptChars =
320 "foo(n) => n == 1 ? throw new Error() : foo(n-1);\n"
321 "testMain() => foo(100);\n";
332 intptr_t frame_count = 0;
335 EXPECT_EQ(101, frame_count);
342 intptr_t line_number = 0;
343 intptr_t column_number = 0;
344 const char* cstr =
"";
351 &line_number, &column_number);
354 EXPECT_STREQ(
"foo", cstr);
356 EXPECT_SUBSTRING(
"test-lib", cstr);
357 EXPECT_EQ(1, line_number);
358 EXPECT_EQ(20, column_number);
361 for (intptr_t frame_index = 1; frame_index < (frame_count - 1);
366 &line_number, &column_number);
369 EXPECT_STREQ(
"foo", cstr);
371 EXPECT_SUBSTRING(
"test-lib", cstr);
372 EXPECT_EQ(1, line_number);
373 EXPECT_EQ(40, column_number);
380 &line_number, &column_number);
383 EXPECT_STREQ(
"testMain", cstr);
385 EXPECT_SUBSTRING(
"test-lib", cstr);
386 EXPECT_EQ(2, line_number);
387 EXPECT_EQ(15, column_number);
397 const char* top_frame_func_name,
398 const char* entry_func_name,
399 int expected_line_number,
400 int expected_column_number) {
410 intptr_t frame_count = 0;
417 intptr_t line_number = 0;
418 intptr_t column_number = 0;
419 const char* cstr =
"";
426 &line_number, &column_number);
429 EXPECT_STREQ(top_frame_func_name, cstr);
432 EXPECT_EQ(expected_line_number, line_number);
433 EXPECT_EQ(expected_column_number, column_number);
442TEST_CASE(DartAPI_StackOverflowStackTraceInfoBraceFunction1) {
447 " static foo(int i) { foo(i); }\n"
449 "testMain() => C.foo(10);\n",
450 "C.foo",
"testMain", line, col);
453TEST_CASE(DartAPI_StackOverflowStackTraceInfoBraceFunction2) {
458 " static foo(int i, int j) {\n"
462 "testMain() => C.foo(10, 11);\n",
463 "C.foo",
"testMain", line, col);
466TEST_CASE(DartAPI_StackOverflowStackTraceInfoArrowFunction) {
471 " static foo(int i) => foo(i);\n"
473 "testMain() => C.foo(10);\n",
474 "C.foo",
"testMain", line, col);
478 const char* kScriptChars =
479 "var number_of_ints = 134000000;\n"
481 " new List<int>(number_of_ints)\n"
501 intptr_t frame_count = 0;
504 EXPECT_EQ(102, frame_count);
511 intptr_t line_number = 0;
512 intptr_t column_number = 0;
513 const char* cstr =
"";
514 const char* test_lib =
"file:///test-lib";
521 &line_number, &column_number);
524 EXPECT_STREQ(
"inspectStack", cstr);
526 EXPECT_STREQ(test_lib, cstr);
527 EXPECT_EQ(3, line_number);
528 EXPECT_EQ(24, column_number);
534 &line_number, &column_number);
537 EXPECT_STREQ(
"foo", cstr);
539 EXPECT_STREQ(test_lib, cstr);
540 EXPECT_EQ(4, line_number);
541 EXPECT_EQ(20, column_number);
544 for (intptr_t frame_index = 2; frame_index < (frame_count - 1);
549 &line_number, &column_number);
552 EXPECT_STREQ(
"foo", cstr);
554 EXPECT_STREQ(test_lib, cstr);
555 EXPECT_EQ(4, line_number);
556 EXPECT_EQ(37, column_number);
563 &line_number, &column_number);
566 EXPECT_STREQ(
"testMain", cstr);
568 EXPECT_STREQ(test_lib, cstr);
569 EXPECT_EQ(5, line_number);
570 EXPECT_EQ(15, column_number);
585 bool* auto_setup_scope) {
586 ASSERT(auto_setup_scope !=
nullptr);
587 *auto_setup_scope =
true;
592 const char* kScriptChars = R
"(
593@pragma("vm:external-name", "CurrentStackTraceNative")
594external inspectStack();
595foo(n) => n == 1 ? inspectStack() : foo(n-1);
596testMain() => foo(100);
606 EXPECT_EQ(42,
value);
656 EXPECT_SUBSTRING(
"Unhandled exception:\nExceptionError",
663 const char* exception_cstr =
"";
666 const char* kApiError =
"Api Error Exception Test.";
674 EXPECT_STREQ(kApiError, exception_cstr);
691 const String& fatal_message =
700 const char* kRegularString =
"Regular String Exception Test.";
707 EXPECT_STREQ(kRegularString, exception_cstr);
721 bool* auto_setup_scope) {
722 ASSERT(auto_setup_scope !=
nullptr);
723 *auto_setup_scope =
true;
728 const char* kScriptChars = R
"(
729import 'dart:isolate';
732 Isolate.current.kill(priority: Isolate.immediate);
735@pragma("vm:external-name", "Test_nativeFunc")
736external void nativeFunc(closure);
739 nativeFunc(() => exitRightNow());
752 EXPECT_SUBSTRING(
"No api calls are allowed while unwind is in progress",
756TEST_CASE(DartAPI_EnsureUnwindErrorHandled_WhenSendAndExit) {
757 const char* kScriptChars = R
"(
758import 'dart:isolate';
761 final receivePort = ReceivePort();
762 Isolate.exit(receivePort.sendPort, true);
765@pragma("vm:external-name", "Test_nativeFunc")
766external void nativeFunc(closure);
769 nativeFunc(() => sendAndExitNow());
782 EXPECT_SUBSTRING(
"No api calls are allowed while unwind is in progress",
812 bool* auto_setup_scope) {
813 ASSERT(auto_setup_scope !=
nullptr);
814 *auto_setup_scope =
true;
819 const char* kScriptChars = R
"(
821 return missing_semicolon
824@pragma("vm:external-name", "Test_nativeFunc")
825external void nativeFunc(closure);
828 nativeFunc(() => raiseCompileError());
862 const char* kScriptChars = R
"(
863void throwException() {
864 throw new Exception('myException');
867@pragma("vm:external-name", "Test_nativeFunc")
868external void nativeFunc(closure);
871 nativeFunc(() => throwException());
943 const char* cstr =
nullptr;
945 EXPECT_STREQ(
"dynamic", cstr);
955 const char* cstr =
nullptr;
957 EXPECT_STREQ(
"void", cstr);
967 const char* cstr =
nullptr;
969 EXPECT_STREQ(
"Never", cstr);
1054 Zone* zone = thread->zone();
1061 const Type& null_type_obj = Api::UnwrapTypeHandle(zone,
type);
1071 const Type& bool_type_obj = Api::UnwrapTypeHandle(zone,
type);
1085 "Dart_InstanceGetType expects argument 'instance' to be of "
1090 const char* kScriptChars =
"int getInt() { return 1; }\n";
1104 const char* result_str =
"";
1106 EXPECT_STREQ(result_str,
"getInt");
1110 const char* kScriptChars =
"int getInt() { return 1; }\n";
1122 const char* url =
"";
1129 const char* lib_url =
"";
1134 EXPECT_STREQ(url, lib_url);
1138 const char* kScriptChars =
1139 "int getInt() { return 1; }\n"
1140 "getTearOff() => getInt;\n"
1141 "Function foo = () { print('baz'); };\n"
1143 " static int foo() => 42;\n"
1144 " getTearOff() => bar;\n"
1145 " int bar() => 24;\n"
1147 "Baz getBaz() => Baz();\n";
1178 bool is_static =
false;
1192 const char* kScriptChars =
1193 "int getInt() { return 1; }\n"
1194 "class Foo { String getString() => 'foobar'; }\n";
1206 bool is_static =
false;
1230 const char* kScriptChars =
"int getInt() { return 1; }\n";
1252 const char* kScriptChars =
1254 " static int getInt() {\n"
1257 " double getDouble() {\n"
1274 EXPECT_SUBSTRING(
"getInt",
result);
1281 EXPECT_SUBSTRING(
"getInt",
result);
1288 EXPECT_SUBSTRING(
"Foo",
result);
1291 "Dart_ClassName expects argument 'cls_type' to be non-null.");
1294 "Dart_GetStaticMethodClosure expects argument 'library' to be non-null.");
1297 "Dart_GetStaticMethodClosure expects argument 'cls_type' to be "
1300 "Dart_GetStaticMethodClosure expects argument 'function_name' "
1312 const char* str =
nullptr;
1314 EXPECT_STREQ(
"dart:core", str);
1360 const double kDoubleVal1 = 201.29;
1361 const double kDoubleVal2 = 101.19;
1369 EXPECT_EQ(kDoubleVal1, out1);
1372 EXPECT_EQ(kDoubleVal2, out2);
1377 const char* kScriptChars =
1378 "int getInt() { return 1; }\n"
1379 "double getDouble() { return 1.0; }\n"
1380 "bool getBool() { return false; }\n"
1381 "getNull() { return null; }\n";
1408 const int64_t kIntegerVal1 = 100;
1409 const int64_t kIntegerVal2 = 0xffffffff;
1410 const char* kIntegerVal3 =
"0x123456789123456789123456789";
1411 const uint64_t kIntegerVal4 = 0xffffffffffffffff;
1412 const int64_t kIntegerVal5 = -0x7fffffffffffffff;
1424 EXPECT_EQ(kIntegerVal1, out);
1434 EXPECT_EQ(kIntegerVal2, out);
1459 } kIntTestCases[] = {
1464 {-0xABCDEF,
"-0xABCDEF"},
1465 {
DART_INT64_C(-0x7FFFFFFFFFFFFFFF),
"-0x7FFFFFFFFFFFFFFF"},
1470 const size_t kNumberOfIntTestCases =
1471 sizeof(kIntTestCases) /
sizeof(kIntTestCases[0]);
1473 for (
size_t i = 0; i < kNumberOfIntTestCases; ++i) {
1476 const char* chars =
nullptr;
1479 EXPECT_STREQ(kIntTestCases[i].
s, chars);
1529 const int kArrayLength = 10;
1537 EXPECT_EQ(kArrayLength, len);
1549 for (
int i = 0; i < kArrayLength; i++) {
1553 for (
int i = 0; i < kArrayLength; i++) {
1559 EXPECT_EQ(i,
value);
1564 uint8_t latin1[] = {
'o',
'n',
'e', 0xC2, 0xA2};
1578 EXPECT_EQ(1, char_size);
1579 EXPECT_EQ(4, str_len);
1582 uint8_t data8[] = {
'o',
'n',
'e', 0x7F};
1589 uint8_t latin1_array[] = {0, 0, 0, 0, 0};
1594 for (intptr_t i = 0; i < len; i++) {
1595 EXPECT_EQ(data8[i], latin1_array[i]);
1598 uint16_t data16[] = {
't',
'w',
'o', 0xFFFF};
1605 EXPECT_EQ(2, char_size);
1606 EXPECT_EQ(4, str_len);
1609 int32_t data32[] = {
'f',
'o',
'u',
'r', 0x10FFFF};
1617 const char* ascii =
"string";
1622 const char* null =
nullptr;
1626 uint8_t
data[] = {0xE4, 0xBA, 0x8c};
1631 uint8_t
invalid[] = {0xE4, 0xBA};
1643 const char* kScriptChars =
1644 "String lowSurrogate() {"
1645 " return '\\u{1D11E}'[1];"
1647 "String highSurrogate() {"
1648 " return '\\u{1D11E}'[0];"
1650 "String reversed() => lowSurrogate() + highSurrogate();";
1656 uint8_t* utf8_encoded =
nullptr;
1657 intptr_t utf8_length = 0;
1660 EXPECT_EQ(3, utf8_length);
1662 EXPECT_EQ(239,
static_cast<intptr_t
>(utf8_encoded[0]));
1663 EXPECT_EQ(191,
static_cast<intptr_t
>(utf8_encoded[1]));
1664 EXPECT_EQ(189,
static_cast<intptr_t
>(utf8_encoded[2]));
1671 uint8_t* utf8_encoded_reversed =
nullptr;
1672 intptr_t utf8_length_reversed = 0;
1674 &utf8_length_reversed);
1676 EXPECT_EQ(6, utf8_length_reversed);
1678 uint8_t expected[6] = {239, 191, 189, 239, 191, 189};
1679 for (
int i = 0; i < 6; i++) {
1680 EXPECT_EQ(expected[i], utf8_encoded_reversed[i]);
1685 const char* kScriptChars =
1686 "String lowSurrogate() {"
1687 " return '\\u{1D11E}'[1];"
1694 uint8_t* utf8_encoded =
nullptr;
1695 intptr_t utf8_length = 0;
1698 EXPECT_EQ(3, utf8_length);
1700 intptr_t utf8_copy_length = 0;
1706 EXPECT_EQ(0, memcmp(utf8_encoded, utf8_encoded_copy, utf8_length));
1712 const int kBigLength = 16 *
MB / 8;
1713 int64_t* big_data =
new int64_t[kBigLength]();
1717 const int kSmallLength = 16 *
KB / 8;
1718 int64_t* small_data =
new int64_t[kSmallLength]();
1720 small_data, kSmallLength);
1734 delete[] small_data;
1739 const char* kScriptChars =
1741 " List a = List.empty(growable: true);"
1748 "List immutable() {"
1749 " return const [0, 1, 2];"
1778 EXPECT_EQ(10,
value);
1784 EXPECT_EQ(20,
value);
1790 EXPECT_EQ(30,
value);
1810 EXPECT_EQ(0,
value);
1816 EXPECT_EQ(1,
value);
1822 EXPECT_EQ(2,
value);
1824 uint8_t native_array[3];
1827 EXPECT_EQ(0, native_array[0]);
1828 EXPECT_EQ(1, native_array[1]);
1829 EXPECT_EQ(2, native_array[2]);
1831 native_array[0] = 10;
1832 native_array[1] = 20;
1833 native_array[2] = 30;
1838 EXPECT_EQ(10, native_array[0]);
1839 EXPECT_EQ(20, native_array[1]);
1840 EXPECT_EQ(30, native_array[2]);
1845 EXPECT_EQ(30,
value);
1854 const int kRangeOffset = 1;
1855 const int kRangeLength = 2;
1867 EXPECT_EQ(20,
value);
1871 EXPECT_EQ(30,
value);
1890 const char* kScriptChars =
1921 EXPECT_EQ(
value, 1);
1981 const char* kScriptChars =
1982 "import 'dart:async';"
1983 "Future testMain() {"
1984 " return new Completer().future;"
2006 const int kSize = 1000;
2008 const char* kScriptChars =
2009 "import 'dart:typed_data';\n"
2010 "List testMain(int size) {\n"
2011 " var a = new Int8List(size);\n"
2012 " var view = new Int8List.view(a.buffer, 0, size);\n"
2023 for (intptr_t i = 0; i <
kSize; ++i) {
2028 for (intptr_t i = 0; i <
kSize; ++i) {
2029 EXPECT_EQ(i & 0xff,
data[i]);
2038 const int kSize = 1000;
2040 const char* kScriptChars =
2041 "import 'dart:typed_data';\n"
2042 "List testMain(int size) {\n"
2043 " var a = new Int8List(size);\n"
2044 " var view = new Int8List.view(a.buffer, 0, size);\n"
2060TEST_CASE(DartAPI_UnmodifiableTypedDataViewListIsTypedData) {
2061 const int kSize = 1000;
2063 const char* kScriptChars =
2064 "import 'dart:typed_data';\n"
2065 "List testMain(int size) {\n"
2066 " var a = new Int8List(size);\n"
2067 " var view = new UnmodifiableInt8ListView(a);\n"
2109 for (intptr_t i = 0; i < 10; ++i) {
2112 for (intptr_t i = 0; i < 10; ++i) {
2116 int64_t int64_t_value = -1;
2118 EXPECT_EQ(i + 1, int64_t_value);
2127 for (intptr_t i = 0; i < 10; ++i) {
2133 for (intptr_t i = 0; i < 10; ++i) {
2142 uint8_t
data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
2143 for (intptr_t i = 0; i < 10; ++i) {
2147 for (intptr_t i = 0; i < 10; ++i) {
2150 int64_t int64_t_value = -1;
2152 EXPECT_EQ(10 - i, int64_t_value);
2161 for (intptr_t i = 0; i < 10; ++i) {
2179 for (intptr_t i = 0; i < 10; ++i) {
2183 int64_t int64_t_value = -1;
2185 EXPECT_EQ(i + 1, int64_t_value);
2212 bool* auto_setup_scope) {
2213 ASSERT(auto_setup_scope !=
nullptr);
2214 *auto_setup_scope =
true;
2219 const char* kScriptChars = R
"(
2220import 'dart:typed_data';
2222 static equals(a, b) {
2224 throw 'not equal. expected: $a, got: $b';
2228@pragma("vm:external-name", "CreateByteData")
2229external ByteData createByteData();
2232 var a = createByteData();
2233 Expect.equals(length, a.lengthInBytes);
2234 for (int i = 0; i < length; i+=1) {
2237 for (int i = 0; i < length; i+=2) {
2238 Expect.equals(0x4242, a.getInt16(i));
2257 0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
2258 0x41, 0x42, 0x41, 0x42, 0x41, 0x42, 0x41, 0x42,
2275 bool* auto_setup_scope) {
2276 ASSERT(auto_setup_scope !=
nullptr);
2277 *auto_setup_scope =
true;
2284 const char* kScriptChars = R
"(
2285import 'dart:typed_data';
2287 static equals(a, b) {
2289 throw 'not equal. expected: $a, got: $b';
2293@pragma("vm:external-name", "CreateExternalByteData")
2294external ByteData createExternalByteData();
2297 var a = createExternalByteData();
2298 Expect.equals(length, a.lengthInBytes);
2299 for (int i = 0; i < length; i+=2) {
2300 Expect.equals(0x4241, a.getInt16(i, Endian.little));
2302 for (int i = 0; i < length; i+=2) {
2304 a.setInt8(i + 1, 0x28);
2306 for (int i = 0; i < length; i+=2) {
2307 Expect.equals(0x2824, a.getInt16(i, Endian.little));
2323 for (intptr_t i = 0; i <
kExtLength; i += 2) {
2324 EXPECT_EQ(0x24,
data[i]);
2325 EXPECT_EQ(0x28,
data[i + 1]);
2339 const char* kScriptChars =
2341 "extractAndSaveArray(byteData) {\n"
2342 " array = byteData.buffer.asUint8List();\n"
2344 "releaseArray() {\n"
2376 GCTestHelper::CollectAllGarbage();
2386 GCTestHelper::CollectAllGarbage();
2396 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
2397 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
2414 bool* auto_setup_scope) {
2415 ASSERT(auto_setup_scope !=
nullptr);
2416 *auto_setup_scope =
true;
2421 const char* kScriptChars = R
"(
2422import 'dart:typed_data';
2424 static equals(a, b) {
2426 throw 'not equal. expected: $a, got: $b';
2430@pragma("vm:external-name", "CreateExternalByteData")
2431external ByteData createExternalByteData();
2433 Expect.equals(0x04030201, a.getUint32(0, Endian.little));
2434 Expect.equals(0x08070605, a.getUint32(4, Endian.little));
2435 Expect.equals(0x0c0b0a09, a.getUint32(8, Endian.little));
2436 Expect.equals(0x100f0e0d, a.getUint32(12, Endian.little));
2440 var a = createExternalByteData();
2441 Expect.equals(length, a.lengthInBytes);
2442 for (int i = 0; i < 20; i++) {
2456 int old_oct = FLAG_optimization_counter_threshold;
2457 FLAG_optimization_counter_threshold = 5;
2460 FLAG_optimization_counter_threshold = old_oct;
2472 "Dart_TypedDataAcquireData expects argument 'type'"
2473 " to be non-null.");
2477 "Dart_TypedDataAcquireData expects argument 'data'"
2478 " to be non-null.");
2482 "Dart_TypedDataAcquireData expects argument 'len'"
2483 " to be non-null.");
2487 "Dart_TypedDataAcquireData expects argument 'object'"
2488 " to be non-null.");
2491 "Dart_TypedDataAcquireData expects argument 'object'"
2492 " to be of type 'TypedData'.");
2496 "Dart_TypedDataReleaseData expects argument 'object'"
2497 " to be non-null.");
2500 "Dart_TypedDataReleaseData expects argument 'object'"
2501 " to be of type 'TypedData'.");
2505 FLAG_verify_acquired_data =
false;
2510 FLAG_verify_acquired_data =
true;
2522 dart_args[0] = array;
2534 EXPECT_EQ(expected_type,
type);
2536 int8_t* dataP =
reinterpret_cast<int8_t*
>(
data);
2537 for (
int i = 0; i <
kLength; i++) {
2538 EXPECT_EQ(i, dataP[i]);
2548 for (
int i = 0; i <
kLength; i++) {
2565 : isolate_group_(isolate_group), monitor_(monitor), done_(
done) {}
2567 const bool kBypassSafepoint =
false;
2570 for (intptr_t i = 0; i < 10; i++) {
2571 GCTestHelper::CollectAllGarbage();
2588 const char* kScriptChars =
2589 "import 'dart:typed_data';\n"
2591 " static equals(a, b) {\n"
2593 " throw new Exception('not equal. expected: $a, got: $b');\n"
2597 "void setMain(var a) {"
2598 " for (var i = 0; i < 10; i++) {"
2602 "bool testMain(var list) {"
2603 " for (var i = 0; i < 10; i++) {"
2604 " Expect.equals((10 + i), list[i]);"
2609 " var a = new Int8List(10);"
2620 for (intptr_t i = 0; i < 10; i++) {
2628 uint8_t
data[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
2631 ext_list_access_test_obj =
2647 FLAG_verify_acquired_data =
false;
2652 FLAG_verify_acquired_data =
true;
2657 const char* kScriptChars =
2658 "import 'dart:typed_data';\n"
2660 " static equals(a, b) {\n"
2662 " throw 'not equal. expected: $a, got: $b';\n"
2666 "void setMain(var list) {"
2667 " Expect.equals(10, list.length);"
2668 " for (var i = 0; i < 10; i++) {"
2672 "bool testMain(var list) {"
2673 " Expect.equals(10, list.length);"
2674 " for (var i = 0; i < 10; i++) {"
2675 " Expect.equals((10 + i), list[i]);"
2680 " var a = new Int8List(100);"
2681 " var view = new Int8List.view(a.buffer, 50, 10);"
2695 FLAG_verify_acquired_data =
false;
2700 FLAG_verify_acquired_data =
true;
2705 const char* kScriptChars =
2706 "import 'dart:typed_data';\n"
2708 " var list = new Int8List(100);"
2709 " for (var i = 0; i < 100; i++) {"
2712 " return new UnmodifiableInt8ListView(list);"
2731 int8_t* dataP =
reinterpret_cast<int8_t*
>(
data);
2732 for (
int i = 0; i <
kLength; i++) {
2733 EXPECT_EQ(i, dataP[i]);
2747TEST_CASE(DartAPI_UnmodifiableTypedDataViewDirectAccessUnverified) {
2748 FLAG_verify_acquired_data =
false;
2752TEST_CASE(DartAPI_UnmodifiableTypedDataViewDirectAccessVerified) {
2753 FLAG_verify_acquired_data =
true;
2758 const char* kScriptChars =
2759 "import 'dart:typed_data';\n"
2761 " static equals(a, b) {\n"
2763 " throw 'not equal. expected: $a, got: $b';\n"
2767 "void setMain(var list) {"
2768 " Expect.equals(10, list.length);"
2769 " for (var i = 0; i < 10; i++) {"
2770 " list.setInt8(i, i);"
2773 "bool testMain(var list) {"
2774 " Expect.equals(10, list.length);"
2775 " for (var i = 0; i < 10; i++) {"
2776 " Expect.equals((10 + i), list.getInt8(i));"
2781 " var a = new Int8List(100);"
2782 " var view = new ByteData.view(a.buffer, 50, 10);"
2796 FLAG_verify_acquired_data =
false;
2801 FLAG_verify_acquired_data =
true;
2805TEST_CASE(DartAPI_NewUnmodifiableExternalTypedDataWithFinalizer) {
2806 const char* kScriptChars = R
"(
2808 static equals(a, b) {
2810 throw 'not equal. expected: $a, got: $b';
2813 static throws(block) {
2815 try { block(); } catch (e) { threw = true; }
2816 if (!threw) throw 'did not throw';
2820 for (var i = 0; i < data.length; i++) {
2821 Expect.equals(i, data[i]);
2822 Expect.throws(() => data[i] = 0);
2826 for (var i = 0; i < data.length; i++) {
2827 Expect.equals(i, data.getUint8(i));
2828 Expect.throws(() => data.setUint8(i, 0));
2834 uint8_t
data[] = {0, 1, 2, 3};
2840 args[0] = typed_data;
2847 int8_t
data[] = {0, 1, 2, 3};
2853 args[0] = typed_data;
2860 uint16_t
data[] = {0, 1, 2, 3};
2867 args[0] = typed_data;
2874 int16_t
data[] = {0, 1, 2, 3};
2880 args[0] = typed_data;
2887 uint32_t
data[] = {0, 1, 2, 3};
2894 args[0] = typed_data;
2901 int32_t
data[] = {0, 1, 2, 3};
2907 args[0] = typed_data;
2914 uint64_t
data[] = {0, 1, 2, 3};
2921 args[0] = typed_data;
2928 int64_t
data[] = {0, 1, 2, 3};
2934 args[0] = typed_data;
2941 float data[] = {0.0f, 1.0f, 2.0f, 3.0f};
2954 double data[] = {0.0, 1.0, 2.0, 3.0};
2961 args[0] = typed_data;
2968 uint8_t
data[] = {0, 1, 2, 3};
2975 args[0] = typed_data;
2983 const char* kScriptChars = R
"(
2984import 'dart:isolate';
2986 var port = new RawReceivePort();
2987 port.handler = (msg) {
2989 if (!identical(original, msg)) throw "got a copy";
2991 port.sendPort.send(original);
2995 uint8_t
data[] = {0, 1, 2, 3};
3001 args[0] = typed_data;
3027 EXPECT_EQ(gc_count_before,
3033 EXPECT_LT(gc_count_before,
3040 intptr_t data_length) {
3045 void* raw_data =
nullptr;
3050 EXPECT_EQ(data_length, len);
3051 EXPECT_EQ(expected_type,
type);
3054 intptr_t list_length = 0;
3056 EXPECT_EQ(data_length, list_length);
3059 for (intptr_t i = 0; i < list_length; ++i) {
3060 EXPECT_EQ(11 * i,
data[i]);
3069 for (intptr_t i = 0; i < data_length; ++i) {
3073 for (intptr_t i = 0; i < list_length; ++i) {
3078 EXPECT_EQ(22 * i,
value);
3082 for (intptr_t i = 0; i < list_length; ++i) {
3088 for (intptr_t i = 0; i < data_length; ++i) {
3089 EXPECT_EQ(33 * i,
data[i]);
3094 uint8_t
data[] = {0, 11, 22, 33, 44, 55, 66, 77};
3103 uint8_t
data[] = {0, 11, 22, 33, 44, 55, 66, 77};
3113 const char* kScriptChars =
3114 "testClamped(List a) {\n"
3115 " if (a[1] != 11) return false;\n"
3117 " if (a[1] != 3) return false;\n"
3119 " if (a[1] != 0) return false;\n"
3121 " if (a[1] != 255) return false;\n"
3125 uint8_t
data[] = {0, 11, 22, 33, 44, 55, 66, 77};
3152 *
static_cast<int*
>(peer) = 42;
3159 uint8_t
data[] = {1, 2, 3, 4};
3169 GCTestHelper::CollectNewSpace();
3176 intptr_t*
count =
reinterpret_cast<intptr_t*
>(peer);
3182 for (intptr_t i = 0; i < 10; i++) {
3192 GCTestHelper::CollectAllGarbage();
3196 EXPECT_EQ(20,
count);
3201 intptr_t*
count =
reinterpret_cast<intptr_t*
>(peer);
3209 for (intptr_t i = 0; i < 10; i++) {
3221 GCTestHelper::CollectAllGarbage();
3225 EXPECT_EQ(20,
count);
3227 for (intptr_t i = 0; i < 20; i++) {
3233 void* raw_data =
nullptr;
3239 float* float_data =
reinterpret_cast<float*
>(raw_data);
3240 for (
int i = 0; i < len * 4; i++) {
3241 EXPECT_EQ(0.0, float_data[i]);
3247 const char* kScriptChars =
3248 "import 'dart:typed_data';\n"
3249 "Float32x4List float32x4() {\n"
3250 " return new Float32x4List(10);\n"
3264 float data[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3265 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3266 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
3267 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
3280 GCTestHelper::CollectNewSpace();
3291 EXPECT(thread !=
nullptr);
3311 const char* kTestString1 =
"Test String1";
3312 const char* kTestString2 =
"Test String2";
3316 EXPECT(isolate !=
nullptr);
3321 const intptr_t handle_count_start =
state->CountPersistentHandles();
3328 for (
int i = 0; i < 1000; i++) {
3333 for (
int i = 1000; i < 2000; i++) {
3336 for (
int i = 500; i < 1500; i++) {
3339 for (
int i = 500; i < 1000; i++) {
3342 for (
int i = 1000; i < 1500; i++) {
3351 for (
int i = 0; i < 500; i++) {
3356 for (
int i = 500; i < 1000; i++) {
3361 for (
int i = 1000; i < 1500; i++) {
3366 for (
int i = 1500; i < 2000; i++) {
3373 EXPECT_EQ(handle_count_start + 2000,
state->CountPersistentHandles());
3383 EXPECT(isolate !=
nullptr);
3409 const char* kTestString1 =
"Test String1";
3410 const char* kTestString2 =
"Test String2";
3416 EXPECT(isolate !=
nullptr);
3506 GCTestHelper::CollectNewSpace();
3526 GCTestHelper::CollectOldSpace();
3550 GCTestHelper::CollectNewSpace();
3566 GCTestHelper::CollectOldSpace();
3582 GCTestHelper::CollectAllGarbage();
3605 void* peer =
reinterpret_cast<void*
>(0);
3611 peer =
reinterpret_cast<void*
>(1);
3635 peer =
reinterpret_cast<void*
>(2);
3641 peer =
reinterpret_cast<void*
>(3);
3650 GCTestHelper::CollectNewSpace();
3662 GCTestHelper::CollectOldSpace();
3678 GCTestHelper::CollectNewSpace();
3691 GCTestHelper::CollectOldSpace();
3704 GCTestHelper::CollectAllGarbage();
3716 EXPECT_EQ(ref1,
static_cast<void*
>(
nullptr));
3723 EXPECT_EQ(ref2,
static_cast<void*
>(
nullptr));
3733 EXPECT_EQ(ref3,
static_cast<void*
>(
nullptr));
3736 const char* kScriptChars = R
"(
3739 final class MyStruct extends Struct {
3740 external Pointer notEmpty;
3743 final class MyUnion extends Union {
3744 external Pointer notEmpty;
3755 EXPECT_EQ(ref4,
static_cast<void*
>(
nullptr));
3763 EXPECT_EQ(ref5,
static_cast<void*
>(
nullptr));
3776 EXPECT_EQ(ref1,
static_cast<void*
>(
nullptr));
3783 EXPECT_EQ(ref2,
static_cast<void*
>(
nullptr));
3793 EXPECT_EQ(ref3,
static_cast<void*
>(
nullptr));
3796 const char* kScriptChars = R
"(
3799 final class MyStruct extends Struct {
3800 external Pointer notEmpty;
3803 final class MyUnion extends Union {
3804 external Pointer notEmpty;
3815 EXPECT_EQ(ref4,
static_cast<void*
>(
nullptr));
3823 EXPECT_EQ(ref5,
static_cast<void*
>(
nullptr));
3833 void* isolate_callback_data,
3838TEST_CASE(DartAPI_WeakPersistentHandleCleanupFinalizerAtShutdown) {
3839 const char* kTestString1 =
"Test String1";
3850 void* isolate_callback_data,
3854 *
static_cast<int*
>(peer) = 42;
3860 const char* kTestString1 =
"Test String1";
3879 GCTestHelper::CollectAllGarbage();
3894 *
static_cast<int*
>(peer) = 42;
3900 const char* kTestString1 =
"Test String1";
3919 GCTestHelper::CollectAllGarbage();
3928 *
static_cast<int*
>(peer) = 42;
3946 GCTestHelper::CollectNewSpace();
3954 *
static_cast<int*
>(peer) = 42;
3969 GCTestHelper::CollectNewSpace();
3991 GCTestHelper::CollectOldSpace();
3993 GCTestHelper::CollectNewSpace();
4018 GCTestHelper::CollectOldSpace();
4020 GCTestHelper::CollectNewSpace();
4029 *
static_cast<int*
>(peer) = 42;
4036 *
static_cast<int*
>(peer) = 42;
4056 GCTestHelper::CollectNewSpace();
4088TEST_CASE(DartAPI_WeakPersistentHandleExternalAllocationSize) {
4093 const intptr_t kWeak1ExternalSize = 1 *
KB;
4105 const intptr_t kWeak2ExternalSize = 2 *
KB;
4120 (kWeak1ExternalSize + kWeak2ExternalSize) /
kWordSize);
4123 GCTestHelper::CollectNewSpace();
4128 GCTestHelper::CollectNewSpace();
4136 GCTestHelper::CollectOldSpace();
4148 const intptr_t kWeak1ExternalSize = 1 *
KB;
4157 const intptr_t kWeak2ExternalSize = 2 *
KB;
4170 (kWeak1ExternalSize + kWeak2ExternalSize) /
kWordSize);
4173 GCTestHelper::CollectNewSpace();
4178 GCTestHelper::CollectNewSpace();
4186 GCTestHelper::CollectOldSpace();
4192TEST_CASE(DartAPI_WeakPersistentHandleExternalAllocationSizeNewspaceGC) {
4196 const intptr_t kWeak1ExternalSize = 500 *
MB;
4229 GCTestHelper::CollectOldSpace();
4234TEST_CASE(DartAPI_FinalizableHandleExternalAllocationSizeNewspaceGC) {
4239 const intptr_t kWeak1ExternalSize = 500 *
MB;
4272 GCTestHelper::CollectOldSpace();
4277TEST_CASE(DartAPI_WeakPersistentHandleExternalAllocationSizeOldspaceGC) {
4286 GCTestHelper::WaitForGCTasks();
4289 const intptr_t kSmallExternalSize = 1 *
KB;
4301 GCTestHelper::WaitForGCTasks();
4302 EXPECT_EQ(kSmallExternalSize,
4306 const intptr_t kHugeExternalSize = (
kWordSize == 4) ? 513 *
MB : 1025 *
MB;
4311 GCTestHelper::WaitForGCTasks();
4320TEST_CASE(DartAPI_FinalizableHandleExternalAllocationSizeOldspaceGC) {
4328 GCTestHelper::WaitForGCTasks();
4331 const intptr_t kSmallExternalSize = 1 *
KB;
4341 GCTestHelper::WaitForGCTasks();
4342 EXPECT_EQ(kSmallExternalSize,
4346 const intptr_t kHugeExternalSize = (
kWordSize == 4) ? 513 *
MB : 1025 *
MB;
4350 GCTestHelper::WaitForGCTasks();
4357TEST_CASE(DartAPI_WeakPersistentHandleExternalAllocationSizeOddReferents) {
4360 const intptr_t kWeak1ExternalSize = 1 *
KB;
4362 const intptr_t kWeak2ExternalSize = 2 *
KB;
4378 (kWeak1ExternalSize + kWeak2ExternalSize) /
kWordSize);
4386 GCTestHelper::CollectOldSpace();
4391TEST_CASE(DartAPI_FinalizableHandleExternalAllocationSizeOddReferents) {
4395 const intptr_t kWeak1ExternalSize = 1 *
KB;
4398 const intptr_t kWeak2ExternalSize = 2 *
KB;
4414 (kWeak1ExternalSize + kWeak2ExternalSize) /
kWordSize);
4424 GCTestHelper::CollectOldSpace();
4438 bool* auto_setup_scope) {
4443 return reinterpret_cast<intptr_t
>(ptr);
4447 if (strcmp(
name,
"returnPtrAsInt") == 0 && argn == 1) {
4454 const char* kScriptChars = R
"(
4456 import 'dart:nativewrappers';
4457 base class SecretKeeper extends NativeFieldWrapperClass1 {
4458 SecretKeeper(int secret) { _keepSecret(secret); }
4459 @pragma("vm:external-name", "SecretKeeper_KeepSecret")
4460 external void _keepSecret(int secret);
4462 // Argument auto-conversion will wrap `o` in `_getNativeField()`.
4463 @Native<IntPtr Function(Pointer<Void>)>(symbol: 'returnPtrAsInt')
4464 external int returnPtrAsInt(NativeFieldWrapperClass1 o);
4465 main() => returnPtrAsInt(SecretKeeper(321));
4482 EXPECT_EQ(321,
value);
4488 const char* kScriptChars = R
"(
4490 import 'dart:nativewrappers';
4491 base class ForgetfulSecretKeeper extends NativeFieldWrapperClass1 {
4492 ForgetfulSecretKeeper(int secret) { /* Forget to init. native field. */ }
4494 // Argument auto-conversion will wrap `o` in `_getNativeField()`.
4495 @Native<IntPtr Function(Pointer<Void>)>(symbol: 'returnPtrAsInt')
4496 external int returnPtrAsInt(NativeFieldWrapperClass1 o);
4497 main() => returnPtrAsInt(ForgetfulSecretKeeper(321));
4519 if (peer == &
weak1) {
4521 }
else if (peer == &
weak2) {
4523 }
else if (peer == &
weak3) {
4577 GCTestHelper::CollectNewSpace();
4656 EXPECT(isolate !=
nullptr);
4669 for (
int i = 0; i < 100; i++) {
4673 for (
int i = 0; i < 100; i++) {
4675 EXPECT_EQ(i, val.
Value());
4683 for (
int i = 100; i < 200; i++) {
4687 for (
int i = 100; i < 200; i++) {
4689 EXPECT_EQ(i, val.
Value());
4698 for (
int i = 200; i < 300; i++) {
4702 for (
int i = 200; i < 300; i++) {
4704 EXPECT_EQ(i, val.
Value());
4727 EXPECT(thread !=
nullptr);
4734 for (
int i = 0; i < 100; i++) {
4741 for (
int i = 0; i < 100; i++) {
4749 for (
int i = 0; i < 200; i++) {
4773 EXPECT_EQ(iso_1, isolate);
4816 intptr_t mydata = 12345;
4819 EXPECT(isolate !=
nullptr);
4829 const uint8_t* kernel_buffer =
nullptr;
4830 intptr_t kernel_buffer_size = 0;
4832 url_str,
source, &kernel_buffer, &kernel_buffer_size);
4833 if (
error !=
nullptr) {
4851 EXPECT_STREQ(
ZONE_STR(
"isolates/%" Pd64, main_port),
id);
4852 free(
const_cast<char*
>(
id));
4866 const char* kScriptChars =
"main() => throw 'HI';";
4882 const char* kScriptChars =
4883 "class MyClass0 {\n"
4886 "class MyClass1 implements MyInterface1 {\n"
4889 "class MyClass2 implements MyInterface0, MyInterface1 {\n"
4892 "abstract class MyInterface0 {\n"
4895 "abstract class MyInterface1 implements MyInterface0 {\n"
4897 "MyClass0 getMyClass0() { return new MyClass0(); }\n"
4898 "MyClass1 getMyClass1() { return new MyClass1(); }\n"
4899 "MyClass2 getMyClass2() { return new MyClass2(); }\n"
4900 "Type getMyClass0Type() { return new MyClass0().runtimeType; }\n"
4901 "Type getMyClass1Type() { return new MyClass1().runtimeType; }\n"
4902 "Type getMyClass2Type() { return new MyClass2().runtimeType; }\n";
4904 bool instanceOf =
false;
4981 const char* kScriptChars =
4982 "class MyClass0<A, B> {\n"
4985 "class MyClass1<A, C> {\n"
4987 "Type type<T>() => T;"
4988 "MyClass0 getMyClass0() {\n"
4989 " return new MyClass0<int, double>();\n"
4991 "Type getMyClass0Type() {\n"
4992 " return type<MyClass0<int, double>>();\n"
4994 "MyClass1 getMyClass1() {\n"
4995 " return new MyClass1<List<int>, List>();\n"
4997 "Type getMyClass1Type() {\n"
4998 " return type<MyClass1<List<int>, List>>();\n"
5000 "MyClass0 getMyClass0_1() {\n"
5001 " return new MyClass0<double, int>();\n"
5003 "Type getMyClass0_1Type() {\n"
5004 " return type<MyClass0<double, int>>();\n"
5006 "MyClass1 getMyClass1_1() {\n"
5007 " return new MyClass1<List<int>, List<double>>();\n"
5009 "Type getMyClass1_1Type() {\n"
5010 " return type<MyClass1<List<int>, List<double>>>();\n"
5012 "Type getIntType() { return int; }\n"
5013 "Type getDoubleType() { return double; }\n"
5014 "Type getListIntType() { return type<List<int>>(); }\n"
5015 "Type getListType() { return List; }\n";
5063 bool instanceOf =
false;
5109 const char* initial_value) {
5115 const char*
value =
"";
5117 EXPECT_STREQ(initial_value,
value);
5120 static int counter = 0;
5137 EXPECT_STREQ(initial_value,
value);
5146 "NoSuchMethodError");
5150 const char* kScriptChars =
5151 "class BaseFields {\n"
5153 " : this.inherited_fld = 'inherited' {\n"
5155 " var inherited_fld;\n"
5156 " static var non_inherited_fld;\n"
5159 "class Fields extends BaseFields {\n"
5161 " : this.instance_fld = 'instance',\n"
5162 " this._instance_fld = 'hidden instance',\n"
5163 " this.final_instance_fld = 'final instance',\n"
5164 " this._final_instance_fld = 'hidden final instance' {\n"
5165 " instance_getset_fld = 'instance getset';\n"
5166 " _instance_getset_fld = 'hidden instance getset';\n"
5169 " static Init() {\n"
5170 " static_fld = 'static';\n"
5171 " _static_fld = 'hidden static';\n"
5172 " static_getset_fld = 'static getset';\n"
5173 " _static_getset_fld = 'hidden static getset';\n"
5176 " var instance_fld;\n"
5177 " var _instance_fld;\n"
5178 " final final_instance_fld;\n"
5179 " final _final_instance_fld;\n"
5180 " static var static_fld;\n"
5181 " static var _static_fld;\n"
5182 " static const const_static_fld = 'const static';\n"
5183 " static const _const_static_fld = 'hidden const static';\n"
5185 " get instance_getset_fld { return _gs_fld1; }\n"
5186 " void set instance_getset_fld(var value) { _gs_fld1 = value; }\n"
5187 " get _instance_getset_fld { return _gs_fld2; }\n"
5188 " void set _instance_getset_fld(var value) { _gs_fld2 = value; }\n"
5192 " static get static_getset_fld { return _gs_fld3; }\n"
5193 " static void set static_getset_fld(var value) { _gs_fld3 = value; }\n"
5194 " static get _static_getset_fld { return _gs_fld4; }\n"
5195 " static void set _static_getset_fld(var value) { _gs_fld4 = value; }\n"
5196 " static var _gs_fld3;\n"
5197 " static var _gs_fld4;\n"
5201 "const const_top_fld = 'const top';\n"
5202 "const _const_top_fld = 'hidden const top';\n"
5204 "get top_getset_fld { return _gs_fld5; }\n"
5205 "void set top_getset_fld(var value) { _gs_fld5 = value; }\n"
5206 "get _top_getset_fld { return _gs_fld6; }\n"
5207 "void set _top_getset_fld(var value) { _gs_fld6 = value; }\n"
5213 " top_fld = 'top';\n"
5214 " _top_fld = 'hidden top';\n"
5215 " top_getset_fld = 'top getset';\n"
5216 " _top_getset_fld = 'hidden top getset';\n"
5217 " return new Fields();\n"
5219 const char* kImportedScriptChars =
5220 "library library_name;\n"
5221 "var imported_fld = 'imported';\n"
5222 "var _imported_fld = 'hidden imported';\n"
5223 "get imported_getset_fld { return _gs_fld1; }\n"
5224 "void set imported_getset_fld(var value) { _gs_fld1 = value; }\n"
5225 "get _imported_getset_fld { return _gs_fld2; }\n"
5226 "void set _imported_getset_fld(var value) { _gs_fld2 = value; }\n"
5230 " imported_getset_fld = 'imported getset';\n"
5231 " _imported_getset_fld = 'hidden imported getset';\n"
5398 const char* kScriptChars =
"var top;\n";
5421 result,
"Dart_SetField expects argument 'value' to be of type Instance.");
5430 const char* kScriptChars =
5436 EXPECT_SUBSTRING(
"type 'bool' is not a subtype of type 'int' of 'foo'",
5446 bool* auto_setup_scope) {
5447 ASSERT(auto_setup_scope !=
nullptr);
5448 *auto_setup_scope =
false;
5456 "class NativeFields extends NativeFieldsWrapper {\n"
5457 " NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
5460 " static int%s fld3;\n"
5461 " static const int fld4 = 10;\n"
5463 "NativeFields testMain() {\n"
5464 " NativeFields obj = new NativeFields(10, 20);\n"
5488 "import 'dart:nativewrappers';"
5489 "final class NativeFields "
5490 "extends NativeFieldWrapperClass2 {\n"
5491 " NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
5493 " final int fld2;\n"
5494 " static int%s fld3;\n"
5495 " static const int fld4 = 10;\n"
5497 "NativeFields testMain() {\n"
5498 " NativeFields obj = new NativeFields(10, 20);\n"
5504 const int kNumNativeFields = 2;
5536 "class NativeFields extends NativeFieldsWrapperClass2 {\n"
5537 " NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
5540 " static int%s fld3;\n"
5541 " static const int fld4 = 10;\n"
5543 "NativeFields testMain() {\n"
5544 " NativeFields obj = new NativeFields(10, 20);\n"
5562 "'dart:test-lib': Error: line 1 pos 36: "
5563 "class 'NativeFields' is trying to extend a native fields class, "
5564 "but library '%s' has no native resolvers",
5590 EXPECT_EQ(0, field_values[0]);
5591 EXPECT_EQ(0, field_values[1]);
5599 "Dart_GetNativeFieldsOfArgument: "
5600 "expected 0 'num_fields' but was passed in 2");
5606 ASSERT(auto_scope !=
nullptr);
5610 if (!obj.IsString()) {
5615 if (strcmp(
function_name,
"TestNativeFieldsAccess_init") == 0) {
5617 }
else if (strcmp(
function_name,
"TestNativeFieldsAccess_access") == 0) {
5619 }
else if (strcmp(
function_name,
"TestNativeFieldsAccess_invalidAccess") ==
5633 import 'dart:nativewrappers';
5634 base class NativeFields extends NativeFieldWrapperClass2 {
5635 NativeFields(int i, int j) : fld1 = i, fld2 = j {}
5639 static const int fld4 = 10;
5640 @pragma('vm:external-name', 'TestNativeFieldsAccess_init')
5641 external int%s initNativeFlds();
5642 @pragma('vm:external-name', 'TestNativeFieldsAccess_access')
5643 external int%s accessNativeFlds(int%s i);
5645 class NoNativeFields {
5646 int neitherATypedDataNorNull = 0;
5647 @pragma('vm:external-name', 'TestNativeFieldsAccess_invalidAccess')
5648 external invalidAccess();
5650 NativeFields testMain() {
5651 NativeFields obj = new NativeFields(10, 20);
5652 obj.initNativeFlds();
5653 obj.accessNativeFlds(null);
5654 new NoNativeFields().invalidAccess();
5658 nullable_tag, nullable_tag, nullable_tag, nullable_tag),
5672 const char* kScriptChars =
5673 "import 'dart:nativewrappers';"
5674 "base class NativeFieldsSuper extends NativeFieldWrapperClass1 {\n"
5675 " NativeFieldsSuper() : fld1 = 42 {}\n"
5678 "base class NativeFields extends NativeFieldsSuper {\n"
5681 "int testMain() {\n"
5682 " NativeFields obj = new NativeFields();\n"
5683 " return obj.fld();\n"
5697 EXPECT_EQ(42,
value);
5711 EXPECT_EQ(10,
value);
5715 EXPECT_EQ(20,
value);
5723 EXPECT_EQ(40,
value);
5726 const int kNativeFld0 = 0;
5727 const int kNativeFld1 = 1;
5728 const int kNativeFld2 = 2;
5729 const int kNativeFld3 = 3;
5730 const int kNativeFld4 = 4;
5731 int field_count = 0;
5732 intptr_t field_value = 0;
5734 EXPECT_EQ(4, field_count);
5739 EXPECT_EQ(0, field_value);
5742 EXPECT_EQ(0, field_value);
5745 EXPECT_EQ(0, field_value);
5748 EXPECT_EQ(0, field_value);
5761 EXPECT_EQ(4000, field_value);
5768 EXPECT_EQ(40,
value);
5772 EXPECT_EQ(20,
value);
5780 "import 'dart:nativewrappers';"
5781 "final class NativeFields extends "
5782 "NativeFieldWrapperClass4 {\n"
5783 " NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
5786 " final int fld2;\n"
5787 " static int%s fld3;\n"
5788 " static const int fld4 = 10;\n"
5790 "NativeFields testMain() {\n"
5791 " NativeFields obj = new NativeFields(10, 20);\n"
5794 nullable_tag, nullable_tag),
5813 "import 'dart:nativewrappers';\n"
5814 "class NativeFields {\n"
5815 " NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
5817 " final int fld2;\n"
5818 " static int%s fld3;\n"
5819 " static const int fld4 = 10;\n"
5821 "NativeFields testMain1() {\n"
5822 " NativeFields obj = new NativeFields(10, 20);\n"
5825 "Function testMain2() {\n"
5845 const int kNativeFld0 = 0;
5846 const int kNativeFld1 = 1;
5847 const int kNativeFld2 = 2;
5848 const int kNativeFld3 = 3;
5849 const int kNativeFld4 = 4;
5887 const char* kScriptChars =
5888 "class TestClass {\n"
5889 " static const int fld1 = 7;\n"
5890 " static int fld2 = 11;\n"
5891 " static void testMain() {\n"
5910 EXPECT_EQ(7,
value);
5915 EXPECT_EQ(11,
value);
5925 EXPECT_EQ(13,
value);
5929 const char* kScriptChars =
5930 "class TestClass {\n"
5931 " static int fld2 = 11;\n"
5932 " static void testMain() {\n"
5947 EXPECT_EQ(11,
value);
5951 const char* kScriptChars =
5952 "class TestClass {\n"
5953 " static int fld2 = 11;\n"
5954 " static void testMain() {\n"
5972 EXPECT_EQ(13,
value);
5976 const char* kScriptChars =
5977 "class MyClass implements MyExtraHop {\n"
5978 " MyClass() : foo = 7 {}\n"
5979 " MyClass.named(value) : foo = value {}\n"
5980 " MyClass._hidden(value) : foo = -value {}\n"
5981 " MyClass.exception(value) : foo = value {\n"
5982 " throw 'ConstructorDeath';\n"
5984 " factory MyClass.multiply(value) {\n"
5985 " return new MyClass.named(value * 100);\n"
5990 "abstract class MyExtraHop implements MyInterface {\n"
5991 " factory MyExtraHop.hop(value) = MyClass.named;\n"
5994 "abstract class MyInterface {\n"
5995 " factory MyInterface.named(value) = MyExtraHop.hop;\n"
5996 " factory MyInterface.multiply(value) = MyClass.multiply;\n"
5997 " MyInterface.notfound(value);\n"
6000 "class _MyClass {\n"
6001 " _MyClass._() : foo = 7 {}\n"
6025 bool instanceOf =
false;
6028 int64_t int_value = 0;
6031 EXPECT_EQ(7, int_value);
6051 EXPECT_EQ(7, int_value);
6065 EXPECT_EQ(7, int_value);
6072 EXPECT_EQ(7, int_value);
6082 EXPECT_EQ(11, int_value);
6095 EXPECT_EQ(11, int_value);
6105 EXPECT_EQ(-11, int_value);
6113 EXPECT_EQ(7, int_value);
6126 EXPECT_EQ(-11, int_value);
6145 EXPECT_EQ(1100, int_value);
6159 "Dart_New expects argument 'number_of_arguments' to be non-negative.");
6165 "Dart_New: wrong argument count for constructor 'MyClass.named': "
6166 "0 passed, 1 expected.");
6176 "Dart_New expects argument 'constructor_name' to be of type String.");
6181 "Dart_New: could not find constructor 'MyClass.missing'.");
6201 const char* kScriptChars =
6202 "class MyClass implements MyExtraHop {\n"
6203 " MyClass() : foo = 7 {}\n"
6204 " MyClass.named(value) : foo = value {}\n"
6205 " MyClass._hidden(value) : foo = -value {}\n"
6206 " MyClass.exception(value) : foo = value {\n"
6207 " throw 'ConstructorDeath';\n"
6209 " factory MyClass.multiply(value) {\n"
6210 " return new MyClass.named(value * 100);\n"
6215 "abstract class MyExtraHop implements MyInterface {\n"
6216 " factory MyExtraHop.hop(value) = MyClass.named;\n"
6219 "abstract class MyInterface {\n"
6220 " factory MyInterface.named(value) = MyExtraHop.hop;\n"
6221 " factory MyInterface.multiply(value) = MyClass.multiply;\n"
6222 " MyInterface.notfound(value);\n"
6238 bool instanceOf =
false;
6244 int64_t int_value = 0;
6247 EXPECT_EQ(11, int_value);
6256 int64_t int_value = 0;
6259 EXPECT_EQ(1100, int_value);
6264 const char* kScriptChars =
6265 "class MyIntClass {\n"
6266 " MyIntClass(this.value);\n"
6270 "class MyClass<T> {\n"
6272 " MyClass(this.value);\n"
6273 " factory MyClass.foo(T x) => MyClass<T>(x);\n"
6276 "Type getIntType() { return int; }\n"
6311 const char* kScriptChars =
6312 "class MyIntClass {\n"
6313 " MyIntClass(this.value);\n"
6317 "class MyClass<T> {\n"
6319 " MyClass(this.value);\n"
6322 "Type getIntType() { return int; }\n"
6355 const char* kScriptChars =
6356 "class InvokeClosure {\n"
6357 " InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
6358 " Function method1(int i) {\n"
6359 " f(int j) => j + i + fld1 + fld2 + fld4; \n"
6363 " final int fld2;\n"
6364 " static const int fld4 = 10;\n"
6366 "Function testMain1() {\n"
6367 " InvokeClosure obj = new InvokeClosure(10, 20);\n"
6368 " return obj.method1(10);\n"
6389 const char* kScriptChars =
6390 "String expectListOfString(List<String> o) => '${o.first}';\n"
6391 "String expectListOfDynamic(List<dynamic> o) => '${o.first}';\n"
6392 "String expectListOfInt(List<int> o) => '${o.first}';\n";
6395 const int kNumArgs = 1;
6401 args[0] = string_list;
6407 EXPECT_STREQ(
"null", str);
6410 "Cannot use legacy types with --sound-null-safety enabled. "
6411 "Use Dart_NewListOfType or Dart_NewListOfTypeFilled instead.");
6416 args[0] = dynamic_list;
6420 EXPECT_STREQ(
"null", str);
6428 EXPECT_STREQ(
"null", str);
6431 "Cannot use legacy types with --sound-null-safety enabled. "
6432 "Use Dart_NewListOfType or Dart_NewListOfTypeFilled instead.");
6437 const char* kScriptChars =
6438 "class ZXHandle {}\n"
6439 "class ChannelReadResult {\n"
6440 " final List<ZXHandle?> handles;\n"
6441 " ChannelReadResult(this.handles);\n"
6443 "void expectListOfString(List<String> _) {}\n"
6444 "void expectListOfDynamic(List<dynamic> _) {}\n"
6445 "void expectListOfVoid(List<void> _) {}\n"
6446 "void expectListOfNever(List<Never> _) {}\n";
6465 const int kNumArgs = 1;
6467 args[0] = zxhandle_list;
6472 "Dart_NewListOfType expects argument 'element_type' to be non-null.");
6475 "Dart_NewListOfType expects argument 'element_type' to be of type Type.");
6485 args[0] = string_list;
6493 args[0] = dynamic_list;
6501 args[0] = void_list;
6508 args[0] = never_list;
6514 const char* kScriptChars =
6515 "class ZXHandle {}\n"
6516 "class ChannelReadResult {\n"
6517 " final List<ZXHandle> handles;\n"
6518 " ChannelReadResult(this.handles);\n"
6549 const int kNumArgs = 1;
6551 args[0] = zxhandle_list;
6555 "Dart_NewListOfTypeFilled expects argument 'element_type' to be "
6558 "Dart_NewListOfTypeFilled expects argument 'element_type' to be "
6562 "Dart_NewListOfTypeFilled expects argument 'fill_object' to be non-null"
6563 " for a non-nullable 'element_type'");
6566 "Dart_NewListOfTypeFilled expects argument 'fill_object' to have the same"
6567 " type as 'element_type'.");
6587 const Library& library_obj = Api::UnwrapLibraryHandle(thread->
zone(), lib);
6593 const char* kScriptChars =
6594 "class BaseMethods {\n"
6595 " inheritedMethod(arg) => 'inherited $arg';\n"
6596 " static nonInheritedMethod(arg) => 'noninherited $arg';\n"
6599 "class Methods extends BaseMethods {\n"
6600 " instanceMethod(arg) => 'instance $arg';\n"
6601 " _instanceMethod(arg) => 'hidden instance $arg';\n"
6602 " static staticMethod(arg) => 'static $arg';\n"
6603 " static _staticMethod(arg) => 'hidden static $arg';\n"
6606 "topMethod(arg) => 'top $arg';\n"
6607 "_topMethod(arg) => 'hidden top $arg';\n"
6609 "Methods test() {\n"
6610 " return new Methods();\n"
6636 EXPECT_STREQ(
"instance !!!", str);
6640 "Class 'Methods' has no instance method 'instanceMethod'"
6641 " with matching arguments");
6649 EXPECT_STREQ(
"hidden instance !!!", str);
6658 EXPECT_STREQ(
"inherited !!!", str);
6667 EXPECT_STREQ(
"static !!!", str);
6671 "NoSuchMethodError: No static method 'staticMethod' with "
6672 "matching arguments");
6681 EXPECT_STREQ(
"hidden static !!!", str);
6696 EXPECT_STREQ(
"top !!!", str);
6700 "NoSuchMethodError: No top-level method 'topMethod' with "
6701 "matching arguments");
6710 EXPECT_STREQ(
"hidden top !!!", str);
6714 const char* kScriptChars =
6716 " static _staticMethod(arg) => 'hidden static $arg';\n"
6734 const char* str =
nullptr;
6736 EXPECT_STREQ(
"hidden static !!!", str);
6740 const char* kScriptChars =
"test(arg) => 'hello $arg';\n";
6752 EXPECT_STREQ(
"hello !!!", str);
6759 EXPECT_STREQ(
"hello null", str);
6775 EXPECT_STREQ(
"Dart_Invoke expects arguments[0] to be an Instance handle.",
6786 const char* kScriptChars =
6787 "class BaseMethods {\n"
6788 " inheritedMethod(int arg) => 'inherited $arg';\n"
6789 " static nonInheritedMethod(int arg) => 'noninherited $arg';\n"
6792 "class Methods extends BaseMethods {\n"
6793 " instanceMethod(int arg) => 'instance $arg';\n"
6794 " _instanceMethod(int arg) => 'hidden instance $arg';\n"
6795 " static staticMethod(int arg) => 'static $arg';\n"
6796 " static _staticMethod(int arg) => 'hidden static $arg';\n"
6799 "topMethod(int arg) => 'top $arg';\n"
6800 "_topMethod(int arg) => 'hidden top $arg';\n"
6802 "Methods test() {\n"
6803 " return new Methods();\n"
6807 const char* error_msg =
6808 "type '_OneByteString' is not a subtype of type 'int' of 'arg'";
6810 const char* error_msg =
6811 "type 'String' is not a subtype of type 'int' of 'arg'";
6874 const char*
value =
"";
6876 EXPECT_STREQ(
"null",
value);
6892 "NoSuchMethodError: The setter 'nullHasNoSetters=' was called on null");
6896 const char* kScriptChars =
6898 " static equals(a, b) {\n"
6900 " throw 'not equal. expected: $a, got: $b';\n"
6904 "class TestClass {\n"
6905 " static int fld1 = 0;\n"
6906 " void noSuchMethod(Invocation invocation) {\n"
6910 " var name = invocation.memberName.toString();\n"
6911 " name = name.split('\"')[1];\n"
6912 " if (name == 'fld') {\n"
6913 " Expect.equals(true, invocation.isGetter);\n"
6914 " Expect.equals(false, invocation.isMethod);\n"
6915 " Expect.equals(false, invocation.isSetter);\n"
6916 " } else if (name == 'setfld') {\n"
6917 " Expect.equals(true, invocation.isSetter);\n"
6918 " Expect.equals(false, invocation.isMethod);\n"
6919 " Expect.equals(false, invocation.isGetter);\n"
6920 " } else if (name == 'method') {\n"
6921 " Expect.equals(true, invocation.isMethod);\n"
6922 " Expect.equals(false, invocation.isSetter);\n"
6923 " Expect.equals(false, invocation.isGetter);\n"
6925 " TestClass.fld1 += 1;\n"
6927 " static TestClass testMain() {\n"
6928 " return new TestClass();\n"
6960 EXPECT_EQ(3,
value);
6964 const char* kScriptChars =
6965 "class InvokeClosure {\n"
6966 " InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
6967 " Function method1(int i) {\n"
6968 " f(int j) => j + i + fld1 + fld2 + fld4; \n"
6971 " static Function method2(int i) {\n"
6972 " n(int j) { throw new Exception('I am an exception'); return 1; }\n"
6976 " final int fld2;\n"
6977 " static const int fld4 = 10;\n"
6979 "Function testMain1() {\n"
6980 " InvokeClosure obj = new InvokeClosure(10, 20);\n"
6981 " return obj.method1(10);\n"
6983 "Function testMain2() {\n"
6984 " return InvokeClosure.method2(10);\n"
7007 EXPECT_EQ(51,
value);
7036 bool* auto_setup_scope) {
7037 ASSERT(auto_setup_scope !=
nullptr);
7038 *auto_setup_scope =
true;
7043 const char* kScriptChars =
7045 @pragma('vm:external-name', 'ThrowException_native')
7046 external int test();
7050 intptr_t size = thread->ZoneSizeInBytes();
7067 EXPECT_EQ(size, thread->ZoneSizeInBytes());
7079 const int num_native_fields = 2;
7093 const int kNumNativeFields = 2;
7097 const char* cstr =
nullptr;
7098 intptr_t native_fields1[kNumNativeFields];
7099 intptr_t native_fields2[kNumNativeFields];
7120 EXPECT(arg_values[0].as_native_fields.values[0] == 30);
7121 EXPECT(arg_values[0].as_native_fields.values[1] == 40);
7123 EXPECT(arg_values[1].as_int32 == 77);
7127 EXPECT(arg_values[2].as_uint64 == 0x8000000000000000LL);
7129 EXPECT(arg_values[3].as_bool ==
true);
7131 EXPECT(arg_values[4].as_double == 3.14);
7136 EXPECT_STREQ(
"abcdefg", cstr);
7137 EXPECT(arg_values[5].as_string.peer ==
nullptr);
7142 EXPECT_STREQ(
"string", cstr);
7143 EXPECT(arg_values[6].as_string.peer ==
nullptr);
7145 EXPECT(arg_values[7].as_native_fields.values[0] == 60);
7146 EXPECT(arg_values[7].as_native_fields.values[1] == 80);
7150 int field_count = 0;
7153 EXPECT(field_count == 2);
7197 bool* auto_scope_setup) {
7200 if (!obj.IsString()) {
7203 ASSERT(auto_scope_setup !=
nullptr);
7204 *auto_scope_setup =
true;
7209 }
else if (strcmp(
function_name,
"NativeArgument_Access") == 0) {
7216 const char* kScriptChars = R
"(
7217import 'dart:nativewrappers';
7218base class MyObject extends NativeFieldWrapperClass2 {
7219 @pragma("vm:external-name", "NativeArgument_Create")
7220 external static MyObject createObject();
7221 @pragma("vm:external-name", "NativeArgument_Access")
7222 external int accessFields(int arg1,
7230int testMain(String extstr) {
7231 String str = 'abcdefg';
7232 MyObject obj1 = MyObject.createObject();
7233 MyObject obj2 = MyObject.createObject();
7234 return obj1.accessFields(77,
7245 const char* ascii_str =
"string";
7246 intptr_t ascii_str_length = strlen(ascii_str);
7248 reinterpret_cast<const uint8_t*
>(ascii_str), ascii_str_length);
7266 bool* auto_setup_scope) {
7267 ASSERT(auto_setup_scope !=
nullptr);
7268 *auto_setup_scope =
true;
7272TEST_CASE(DartAPI_GetNativeArgumentCount) {
7273 const char* kScriptChars = R
"(
7275 @pragma("vm:external-name", "Name_Does_Not_Matter")
7276 external int method1(int i, int j);
7279 MyObject obj = new MyObject();
7280 return obj.method1(77, 125);
7292 EXPECT_EQ(3, value);
7296 const char* kScriptChars =
7297 "library testlib;\n"
7299 " static var name = 'Class';\n"
7312 "Cannot use legacy types with --sound-null-safety enabled. "
7313 "Use Dart_GetNullableType or Dart_GetNonNullableType instead.");
7355 const char* kScriptChars =
7356 "library testlib;\n"
7358 " static var name = 'Class';\n"
7362 " static var name = '_Class';\n"
7375 const char* name_cstr =
"";
7377 EXPECT_STREQ(
"Class?", name_cstr);
7382 EXPECT_STREQ(
"Class", name_cstr);
7394 EXPECT_STREQ(
"_Class", name_cstr);
7399 EXPECT_STREQ(
"Type 'DoesNotExist' not found in library 'testlib'.",
7415 const char* kScriptChars =
7416 "library testlib;\n"
7418 " static var name = 'Class';\n"
7422 " static var name = '_Class';\n"
7436 const char* name_cstr =
"";
7438 EXPECT_STREQ(
"Class", name_cstr);
7443 EXPECT_STREQ(
"Class", name_cstr);
7456 EXPECT_STREQ(
"_Class", name_cstr);
7461 EXPECT_STREQ(
"Type 'DoesNotExist' not found in library 'testlib'.",
7477 const char* kScriptChars =
7478 "class OtherClass {\n"
7479 " static returnNull() { return null; }\n"
7481 "class InstanceOfTest {\n"
7482 " InstanceOfTest() {}\n"
7483 " static InstanceOfTest testMain() {\n"
7484 " return new InstanceOfTest();\n"
7503 bool is_instance =
false;
7545 const char* kScriptChars =
7562 const char* uri_cstr =
"";
7583 EXPECT_STREQ(
"dart:core", uri_cstr);
7592 const char* kScriptChars =
7593 "import 'library1_dart';"
7595 const char* kLibrary1 =
"file:///library1_dart";
7596 const char* kLibrary1Chars =
7617 "Dart_LookupLibrary expects argument 'url' to be non-null.");
7622 "Dart_LookupLibrary expects argument 'url' to be of type String.");
7634 const char* kLibrary1Chars =
"library library1_name;";
7641 "Dart_LibraryUrl expects argument 'library' to be non-null.");
7646 "Dart_LibraryUrl expects argument 'library' to be of type Library.");
7655 const char* cstr =
nullptr;
7657 EXPECT_SUBSTRING(
"library1_url", cstr);
7674 bool* auto_setup_scope) {
7675 ASSERT(auto_setup_scope !=
nullptr);
7676 *auto_setup_scope =
false;
7682 bool* auto_setup_scope) {
7683 ASSERT(auto_setup_scope !=
nullptr);
7684 *auto_setup_scope =
false;
7689 const char* kScriptChars =
7692 @pragma('vm:external-name', 'SomeNativeFunction')
7693 external static foo();
7695 @pragma('vm:external-name', 'SomeNativeFunction2')
7696 external static bar();
7698 @pragma('vm:external-name', 'SomeNativeFunction3')
7699 external static baz();
7718 "Dart_SetNativeResolver expects argument 'library' to be non-null.");
7722 "Dart_SetNativeResolver expects argument 'library' to be of "
7738 EXPECT_EQ(654321,
value);
7750 EXPECT_EQ(654321,
value);
7758 EXPECT_EQ(123456, value);
7765 "native function 'SomeNativeFunction3' (0 arguments) "
7772 const char* kScriptChars =
7773 "import 'library1_dart';\n"
7775 "main() { foo = 0; }\n";
7776 const char* kLibrary1Chars =
7777 "library library1_dart;\n"
7778 "import 'library2_dart';\n"
7780 const char* kLibrary2Chars =
7781 "library library2_dart;\n"
7782 "import 'library1_dart';\n"
7790 {
"file:///library1_dart", kLibrary1Chars},
7791 {
"file:///library2_dart", kLibrary2Chars},
7793 int sourcefiles_count =
sizeof(sourcefiles) /
sizeof(
Dart_SourceFile);
7807 const char* kScriptChars =
7808 "import 'file:///library2_dart';\n"
7809 "import 'file:///library1_dart';\n"
7810 "var foo_top = 10; // foo has dup def. So should be an error.\n"
7811 "main() { foo = 0; }\n";
7812 const char* kLibrary1Chars =
7813 "library library1_dart;\n"
7815 const char* kLibrary2Chars =
7816 "library library2_dart;\n"
7824 {
"file:///library2_dart", kLibrary2Chars},
7825 {
"file:///library1_dart", kLibrary1Chars},
7827 int sourcefiles_count =
sizeof(sourcefiles) /
sizeof(
Dart_SourceFile);
7831 "Compilation failed /test-lib:4:10:"
7832 " Error: Setter not found: 'foo'");
7845 const char* kScriptChars =
7846 "import 'library2_dart';\n"
7847 "import 'library1_dart';\n"
7849 const char* kLibrary1Chars =
7850 "library library1_dart;\n"
7852 const char* kLibrary2Chars =
7853 "library library2_dart;\n"
7861 {
"file:///library2_dart", kLibrary2Chars},
7862 {
"file:///library1_dart", kLibrary1Chars},
7864 int sourcefiles_count =
sizeof(sourcefiles) /
sizeof(
Dart_SourceFile);
7876 const char* kScriptChars =
7877 "import 'lib.dart';\n"
7878 "abstract class Y {\n"
7879 " void set handler(void callback(List<int> x));\n"
7882 const char* kLibraryChars =
7883 "library lib.dart;\n"
7884 "abstract class X {\n"
7885 " void set handler(void callback(List<int> x));\n"
7893 {
"file:///lib.dart", kLibraryChars},
7895 int sourcefiles_count =
sizeof(sourcefiles) /
sizeof(
Dart_SourceFile);
7907 const char* kScriptChars =
7908 "import 'lib.dart';\n"
7910 const char* kLibraryChars =
"library lib.dart;\n";
7915 {
"file:///bar/main.dart", kScriptChars},
7916 {
"file:///baz/lib.dart", kLibraryChars},
7917 {
"file:///bar/.packages",
""},
7919 int sourcefiles_count =
sizeof(sourcefiles) /
sizeof(
Dart_SourceFile);
7921 sourcefiles_count, sourcefiles,
nullptr,
true,
7928 TransitionNativeToVM transition(thread);
7932 const Array& lib_scripts =
Array::Handle(lib_obj.LoadedScripts());
7935 for (intptr_t i = 0; i < lib_scripts.Length(); i++) {
7936 script ^= lib_scripts.At(i);
7939 EXPECT(strstr(uri_str,
"foo:///") == uri_str);
7948TEST_CASE(DartAPI_Multiroot_FailWhenUriIsWrong) {
7949 const char* kScriptChars =
7950 "import 'lib.dart';\n"
7952 const char* kLibraryChars =
"library lib.dart;\n";
7956 {
"file:///bar/main.dart", kScriptChars},
7957 {
"file:///baz/lib.dart", kLibraryChars},
7958 {
"file:///bar/.packages",
"untitled:/"},
7960 int sourcefiles_count =
sizeof(sourcefiles) /
sizeof(
Dart_SourceFile);
7962 sourcefiles_count, sourcefiles,
nullptr,
true,
7964 "foo1:///main.dart",
7968 "Compilation failed Invalid argument(s): Exception when reading "
7969 "'foo1:///.dart_tool");
8020TEST_CASE(DartAPI_PostCObject_DoesNotRunFinalizerOnFailure) {
8022 Utils::StrDup(
"Ownership of this memory remains with the caller");
8027 message.value.as_external_typed_data.length = strlen(my_str);
8028 message.value.as_external_typed_data.data =
8029 reinterpret_cast<uint8_t*
>(my_str);
8030 message.value.as_external_typed_data.peer = my_str;
8048 TestIsolateScope __test_isolate__;
8049 const char* kScriptChars =
8050 "import 'dart:isolate';\n"
8051 "void callPort(SendPort port) {\n"
8052 " var receivePort = new RawReceivePort();\n"
8053 " var replyPort = receivePort.sendPort;\n"
8054 " port.send(<dynamic>[replyPort]);\n"
8055 " receivePort.handler = (message) {\n"
8056 " receivePort.close();\n"
8057 " throw new Exception(message);\n"
8074 dart_args[0] = send_port1;
8083 dart_args[0] = send_port2;
8122TEST_CASE(DartAPI_NativePortPostInteger) {
8123 const char* kScriptChars =
8124 "import 'dart:isolate';\n"
8125 "void callPort(SendPort port) {\n"
8126 " var receivePort = new RawReceivePort();\n"
8127 " var replyPort = receivePort.sendPort;\n"
8128 " port.send(<dynamic>[replyPort]);\n"
8129 " receivePort.handler = (message) {\n"
8130 " receivePort.close();\n"
8131 " throw new Exception(message);\n"
8149 dart_args[0] = send_port1;
8158 dart_args[0] = send_port2;
8179 EXPECT_EQ(10,
message->value.as_typed_data.length);
8180 EXPECT_EQ(42,
message->value.as_typed_data.values[0]);
8181 free(
const_cast<uint8_t*
>(
message->value.as_typed_data.values));
8189 EXPECT_EQ(1,
message->value.as_array.length);
8198TEST_CASE(DartAPI_NativePortPostTransferrableTypedData) {
8199 const char* kScriptChars =
8200 "import 'dart:typed_data';\n"
8201 "import 'dart:isolate';\n"
8202 "void callPort(SendPort port1, SendPort port2) {\n"
8204 " TransferableTypedData.fromList([Uint8List(10)..[0] = 42]);\n"
8206 " TransferableTypedData.fromList([Uint8List(10)..[0] = 42]);\n"
8207 " port1.send(td1);\n"
8208 " port2.send([td2]);\n"
8225 dart_args[0] = send_port1;
8226 dart_args[1] = send_port2;
8249 EXPECT_EQ((0x41 + i),
message->value.as_typed_data.values[i]);
8254 delete[]
reinterpret_cast<int8_t*
>(peer);
8257TEST_CASE(DartAPI_NativePortPostExternalTypedData) {
8260 extTypedData[i] = 0x41 + i;
8262 const char* kScriptChars =
8263 "import 'dart:typed_data';\n"
8264 "import 'dart:isolate';\n"
8265 "void callPort(SendPort port, Uint8List data) {\n"
8266 " port.send(data);\n"
8284 dart_args[0] = send_port;
8285 dart_args[1] = extdata;
8302TEST_CASE(DartAPI_NativePortPostUserClass) {
8303 const char* kScriptChars =
8304 "import 'dart:isolate';\n"
8306 "void callPort(SendPort port) {\n"
8307 " port.send(new ABC());\n"
8320 dart_args[0] = send_port;
8331 dart_args[0] = send_port;
8353TEST_CASE(DartAPI_NativePortReceiveNull) {
8354 const char* kScriptChars =
8355 "import 'dart:isolate';\n"
8356 "void callPort(SendPort port) {\n"
8357 " var receivePort = new RawReceivePort();\n"
8358 " var replyPort = receivePort.sendPort;\n"
8359 " port.send(null);\n"
8360 " port.send(<dynamic>[replyPort]);\n"
8361 " receivePort.handler = (message) {\n"
8362 " receivePort.close();\n"
8363 " throw new Exception(message);\n"
8376 dart_args[0] = send_port1;
8401 EXPECT_EQ(
message->value.as_int32, 321);
8405TEST_CASE(DartAPI_NativePortReceiveInteger) {
8406 const char* kScriptChars =
8407 "import 'dart:isolate';\n"
8408 "void callPort(SendPort port) {\n"
8409 " var receivePort = new RawReceivePort();\n"
8410 " var replyPort = receivePort.sendPort;\n"
8411 " port.send(321);\n"
8412 " port.send(<dynamic>[replyPort]);\n"
8413 " receivePort.handler = (message) {\n"
8414 " receivePort.close();\n"
8415 " throw new Exception(message);\n"
8428 dart_args[0] = send_port1;
8444 const char* package_root,
8445 const char* package_config,
8449 const char* kScriptChars =
8450 "import 'dart:isolate';\n"
8451 "void main(shouldThrowException) {\n"
8452 " var rp = new RawReceivePort();\n"
8453 " rp.handler = (msg) {\n"
8455 " if (shouldThrowException) {\n"
8456 " throw new Exception('ExceptionFromTimer');\n"
8459 " rp.sendPort.send(1);\n"
8466 ASSERT(isolate !=
nullptr);
8478 EXPECT(err_msg ==
nullptr);
8487 nullptr,
nullptr,
nullptr);
8500 if (throw_exception) {
8572 void* my_group_data =
reinterpret_cast<void*
>(123);
8573 void* my_data =
reinterpret_cast<void*
>(456);
8578 EXPECT(isolate !=
nullptr);
8606 void* isolate_data) {
8629 const char* kScriptChars =
8630 "int add(int a, int b) {\n"
8640 EXPECT(isolate !=
nullptr);
8693 int64_t integer_value = 0;
8696 EXPECT_EQ(value, integer_value);
8697 double double_value;
8731 bool* auto_setup_scope) {
8732 ASSERT(auto_setup_scope !=
nullptr);
8733 *auto_setup_scope =
false;
8736 if (!obj.IsString()) {
8740 const char* kNativeFoo1 =
"NativeFoo1";
8741 const char* kNativeFoo2 =
"NativeFoo2";
8742 const char* kNativeFoo3 =
"NativeFoo3";
8743 const char* kNativeFoo4 =
"NativeFoo4";
8746 }
else if (strncmp(
function_name, kNativeFoo2, strlen(kNativeFoo2)) == 0) {
8748 }
else if (strncmp(
function_name, kNativeFoo3, strlen(kNativeFoo3)) == 0) {
8750 }
else if (strncmp(
function_name, kNativeFoo4, strlen(kNativeFoo4)) == 0) {
8758TEST_CASE(DartAPI_NativeFunctionClosure) {
8759 const char* kScriptChars =
8762 @pragma('vm:external-name', 'NativeFoo1')
8763 external int foo1();
8765 @pragma('vm:external-name', 'NativeFoo2')
8766 external int foo2(int i);
8768 @pragma('vm:external-name', 'NativeFoo3')
8769 external int foo3([int k = 10000, int l = 1]);
8771 @pragma('vm:external-name', 'NativeFoo4')
8772 external int foo4(int i, [int j = 10, int k = 1]);
8774 int bar1() { var func = foo1; return func(); }
8775 int bar2(int i) { var func = foo2; return func(i); }
8776 int bar30() { var func = foo3; return func(); }
8777 int bar31(int i) { var func = foo3; return func(i); }
8778 int bar32(int i, int j) { var func = foo3; return func(i, j); }
8780 var func = foo4; return func(i); }
8781 int bar42(int i, int j) {
8782 var func = foo4; return func(i, j); }
8783 int bar43(int i, int j, int k) {
8784 var func = foo4; return func(i, j, k); }
8787 static equals(a, b) {
8789 throw 'not equal. expected: $a, got: $b';
8794 Test obj = new Test();
8795 Expect.equals(1, obj.foo1());
8796 Expect.equals(1, obj.bar1());
8798 Expect.equals(10, obj.foo2(10));
8799 Expect.equals(10, obj.bar2(10));
8801 Expect.equals(10001, obj.foo3());
8802 Expect.equals(10001, obj.bar30());
8803 Expect.equals(2, obj.foo3(1));
8804 Expect.equals(2, obj.bar31(1));
8805 Expect.equals(4, obj.foo3(2, 2));
8806 Expect.equals(4, obj.bar32(2, 2));
8808 Expect.equals(12, obj.foo4(1));
8809 Expect.equals(12, obj.bar41(1));
8810 Expect.equals(3, obj.foo4(1, 1));
8811 Expect.equals(3, obj.bar42(1, 1));
8812 Expect.equals(6, obj.foo4(2, 2, 2));
8813 Expect.equals(6, obj.bar43(2, 2, 2));
8835 EXPECT_EQ(0, value);
8880 bool* auto_setup_scope) {
8881 ASSERT(auto_setup_scope !=
nullptr);
8882 *auto_setup_scope =
false;
8885 if (!obj.IsString()) {
8889 const char* kNativeFoo1 =
"StaticNativeFoo1";
8890 const char* kNativeFoo2 =
"StaticNativeFoo2";
8891 const char* kNativeFoo3 =
"StaticNativeFoo3";
8892 const char* kNativeFoo4 =
"StaticNativeFoo4";
8893 if (strncmp(
function_name, kNativeFoo1, strlen(kNativeFoo1)) == 0) {
8895 }
else if (strncmp(
function_name, kNativeFoo2, strlen(kNativeFoo2)) == 0) {
8897 }
else if (strncmp(
function_name, kNativeFoo3, strlen(kNativeFoo3)) == 0) {
8899 }
else if (strncmp(
function_name, kNativeFoo4, strlen(kNativeFoo4)) == 0) {
8907TEST_CASE(DartAPI_NativeStaticFunctionClosure) {
8908 const char* kScriptChars =
8911 @pragma('vm:external-name', 'StaticNativeFoo1')
8912 external static int foo1();
8914 @pragma('vm:external-name', 'StaticNativeFoo2')
8915 external static int foo2(int i);
8917 @pragma('vm:external-name', 'StaticNativeFoo3')
8918 external static int foo3([int k = 10000, int l = 1]);
8920 @pragma('vm:external-name', 'StaticNativeFoo4')
8921 external static int foo4(int i, [int j = 10, int k = 1]);
8923 int bar1() { var func = foo1; return func(); }
8924 int bar2(int i) { var func = foo2; return func(i); }
8925 int bar30() { var func = foo3; return func(); }
8926 int bar31(int i) { var func = foo3; return func(i); }
8927 int bar32(int i, int j) { var func = foo3; return func(i, j); }
8929 var func = foo4; return func(i); }
8930 int bar42(int i, int j) {
8931 var func = foo4; return func(i, j); }
8932 int bar43(int i, int j, int k) {
8933 var func = foo4; return func(i, j, k); }
8936 static equals(a, b) {
8938 throw 'not equal. expected: $a, got: $b';
8943 Test obj = new Test();
8944 Expect.equals(0, Test.foo1());
8945 Expect.equals(0, obj.bar1());
8947 Expect.equals(10, Test.foo2(10));
8948 Expect.equals(10, obj.bar2(10));
8950 Expect.equals(10001, Test.foo3());
8951 Expect.equals(10001, obj.bar30());
8952 Expect.equals(2, Test.foo3(1));
8953 Expect.equals(2, obj.bar31(1));
8954 Expect.equals(4, Test.foo3(2, 2));
8955 Expect.equals(4, obj.bar32(2, 2));
8957 Expect.equals(12, Test.foo4(1));
8958 Expect.equals(12, obj.bar41(1));
8959 Expect.equals(3, Test.foo4(1, 1));
8960 Expect.equals(3, obj.bar42(1, 1));
8961 Expect.equals(6, Test.foo4(2, 2, 2));
8962 Expect.equals(6, obj.bar43(2, 2, 2));
8984 EXPECT_EQ(0, value);
8988 uint8_t chars8[1] = {
'a'};
8989 uint16_t chars16[1] = {
'a'};
8990 int32_t chars32[1] = {
'a'};
8993 "expects argument 'length' to be in the range");
8995 "expects argument 'length' to be in the range");
8997 "expects argument 'length' to be in the range");
8999 "expects argument 'length' to be in the range");
9001 "expects argument 'length' to be in the range");
9004 "expects argument 'length' to be in the range");
9006 "expects argument 'length' to be in the range");
9009 "expects argument 'length' to be in the range");
9073 EXPECT_EQ(0, heap->PeerCount());
9079 EXPECT_EQ(1, heap->PeerCount());
9082 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9087 EXPECT_EQ(0, heap->PeerCount());
9093TEST_CASE(DartAPI_CollectOneNewSpacePeer) {
9101 EXPECT_EQ(0, heap->PeerCount());
9107 EXPECT_EQ(1, heap->PeerCount());
9110 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9112 TransitionNativeToVM transition(thread);
9113 GCTestHelper::CollectNewSpace();
9114 EXPECT_EQ(1, heap->PeerCount());
9118 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9122 TransitionNativeToVM transition(thread);
9123 GCTestHelper::CollectNewSpace();
9124 EXPECT_EQ(0, heap->PeerCount());
9139 EXPECT_EQ(0, heap->PeerCount());
9142 EXPECT_EQ(1, heap->PeerCount());
9144 EXPECT(o1 ==
reinterpret_cast<void*
>(&p1));
9148 EXPECT_EQ(1, heap->PeerCount());
9154 EXPECT_EQ(2, heap->PeerCount());
9156 EXPECT(o2 ==
reinterpret_cast<void*
>(&p2));
9158 EXPECT_EQ(1, heap->PeerCount());
9162 EXPECT_EQ(0, heap->PeerCount());
9170TEST_CASE(DartAPI_CollectTwoNewSpacePeers) {
9178 EXPECT_EQ(0, heap->PeerCount());
9184 EXPECT_EQ(1, heap->PeerCount());
9186 EXPECT(o1 ==
reinterpret_cast<void*
>(&p1));
9190 EXPECT_EQ(1, heap->PeerCount());
9196 EXPECT_EQ(2, heap->PeerCount());
9198 EXPECT(o2 ==
reinterpret_cast<void*
>(&p2));
9202 TransitionNativeToVM transition(thread);
9203 GCTestHelper::CollectNewSpace();
9204 EXPECT_EQ(0, heap->PeerCount());
9211 const int kPeerCount = 10;
9214 for (
int i = 0; i < kPeerCount; ++i) {
9222 EXPECT_EQ(0, heap->PeerCount());
9224 for (
int i = 0; i < kPeerCount; ++i) {
9226 EXPECT_EQ(i + 1, heap->PeerCount());
9229 EXPECT(o ==
reinterpret_cast<void*
>(&p[i]));
9231 EXPECT_EQ(kPeerCount, heap->PeerCount());
9233 TransitionNativeToVM transition(thread);
9234 GCTestHelper::CollectNewSpace();
9235 EXPECT_EQ(kPeerCount, heap->PeerCount());
9236 GCTestHelper::CollectNewSpace();
9237 EXPECT_EQ(kPeerCount, heap->PeerCount());
9249 EXPECT_EQ(0, heap->PeerCount());
9257 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9258 EXPECT_EQ(1, heap->PeerCount());
9260 TransitionNativeToVM transition(thread);
9261 GCTestHelper::CollectNewSpace();
9262 GCTestHelper::CollectNewSpace();
9266 TransitionNativeToVM transition(thread);
9273 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9274 EXPECT_EQ(1, heap->PeerCount());
9279 EXPECT_EQ(0, heap->PeerCount());
9290 EXPECT_EQ(0, heap->PeerCount());
9296 EXPECT_EQ(1, heap->PeerCount());
9299 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9301 TransitionNativeToVM transition(thread);
9302 GCTestHelper::CollectOldSpace();
9303 EXPECT_EQ(1, heap->PeerCount());
9306 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9311 EXPECT_EQ(0, heap->PeerCount());
9317TEST_CASE(DartAPI_CollectOneOldSpacePeer) {
9326 EXPECT_EQ(0, heap->PeerCount());
9332 EXPECT_EQ(1, heap->PeerCount());
9335 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9337 TransitionNativeToVM transition(thread);
9338 GCTestHelper::CollectOldSpace();
9339 EXPECT_EQ(1, heap->PeerCount());
9342 EXPECT(out ==
reinterpret_cast<void*
>(&peer));
9346 TransitionNativeToVM transition(thread);
9347 GCTestHelper::CollectOldSpace();
9348 EXPECT_EQ(0, heap->PeerCount());
9360 EXPECT_EQ(0, heap->PeerCount());
9366 EXPECT_EQ(1, heap->PeerCount());
9369 EXPECT(o1 ==
reinterpret_cast<void*
>(&p1));
9373 EXPECT_EQ(1, heap->PeerCount());
9379 EXPECT_EQ(2, heap->PeerCount());
9382 EXPECT(o2 ==
reinterpret_cast<void*
>(&p2));
9384 EXPECT_EQ(1, heap->PeerCount());
9389 EXPECT_EQ(0, heap->PeerCount());
9398TEST_CASE(DartAPI_CollectTwoOldSpacePeers) {
9407 EXPECT_EQ(0, heap->PeerCount());
9413 EXPECT_EQ(1, heap->PeerCount());
9416 EXPECT(o1 ==
reinterpret_cast<void*
>(&p1));
9420 EXPECT_EQ(1, heap->PeerCount());
9426 EXPECT_EQ(2, heap->PeerCount());
9429 EXPECT(o2 ==
reinterpret_cast<void*
>(&p2));
9434 GCTestHelper::CollectOldSpace();
9435 EXPECT_EQ(0, heap->PeerCount());
9439TEST_CASE(DartAPI_StringFromExternalTypedData) {
9440 const char* kScriptChars =
9441 "test(external) {\n"
9442 " var str1 = new String.fromCharCodes(external);\n"
9443 " var str2 = new String.fromCharCodes(new List.from(external));\n"
9444 " if (str2 != str1) throw 'FAIL';\n"
9447 "testView8(external) {\n"
9448 " return test(external.buffer.asUint8List());\n"
9450 "testView16(external) {\n"
9451 " return test(external.buffer.asUint16List());\n"
9457 for (
int i = 0; i < 64; i++) {
9465 dart_args[0] = external;
9477 for (
int i = 0; i < 64; i++) {
9485 dart_args[0] = external;
9497 for (
int i = 0; i < 64; i++) {
9498 data[i] = 0x2000 + i * 4;
9505 dart_args[0] = external;
9521 TimelineStream*
stream = Timeline::GetEmbedderStream();
9523 stream->set_enabled(
true);
9528 TimelineEventRecorder* recorder = Timeline::recorder();
9530 IsolateTimelineEventFilter filter(isolate->main_port());
9531 recorder->PrintJSON(&js, &filter);
9532 const char* json =
js.ToCString();
9533 EXPECT_SUBSTRING(
"\"name\":\"testDurationEvent\"", json);
9534 EXPECT_SUBSTRING(
"\"ph\":\"X\"", json);
9535 EXPECT_SUBSTRING(
"\"ts\":500", json);
9536 EXPECT_SUBSTRING(
"\"dur\":1000", json);
9542 TimelineStream*
stream = Timeline::GetEmbedderStream();
9544 stream->set_enabled(
true);
9549 TimelineEventRecorder* recorder = Timeline::recorder();
9551 IsolateTimelineEventFilter filter(isolate->main_port());
9552 recorder->PrintJSON(&js, &filter);
9553 const char* json =
js.ToCString();
9554 EXPECT_SUBSTRING(
"\"name\":\"testBeginEvent\"", json);
9555 EXPECT_SUBSTRING(
"\"ph\":\"B\"", json);
9556 EXPECT_SUBSTRING(
"\"ts\":1000", json);
9562 TimelineStream*
stream = Timeline::GetEmbedderStream();
9564 stream->set_enabled(
true);
9569 TimelineEventRecorder* recorder = Timeline::recorder();
9571 IsolateTimelineEventFilter filter(isolate->main_port());
9572 recorder->PrintJSON(&js, &filter);
9573 const char* json =
js.ToCString();
9574 EXPECT_SUBSTRING(
"\"name\":\"testEndEvent\"", json);
9575 EXPECT_SUBSTRING(
"\"ph\":\"E\"", json);
9576 EXPECT_SUBSTRING(
"\"ts\":1000", json);
9582 TimelineStream* stream = Timeline::GetEmbedderStream();
9584 stream->set_enabled(
true);
9588 TimelineEventRecorder* recorder = Timeline::recorder();
9590 IsolateTimelineEventFilter filter(isolate->main_port());
9591 recorder->PrintJSON(&js, &filter);
9592 const char* json = js.ToCString();
9593 EXPECT_SUBSTRING(
"\"name\":\"testInstantEvent\"", json);
9594 EXPECT_SUBSTRING(
"\"ph\":\"i\"", json);
9595 EXPECT_SUBSTRING(
"\"ts\":1000", json);
9598TEST_CASE(DartAPI_TimelineAsyncDisabled) {
9600 TimelineStream* stream = Timeline::GetEmbedderStream();
9602 stream->set_enabled(
false);
9603 int64_t async_id = 99;
9608 TimelineEventRecorder* recorder = Timeline::recorder();
9610 TimelineEventFilter filter;
9611 recorder->PrintJSON(&js, &filter);
9612 EXPECT_NOTSUBSTRING(
"testAsyncEvent", js.ToCString());
9618 TimelineStream*
stream = Timeline::GetEmbedderStream();
9620 stream->set_enabled(
true);
9621 int64_t async_id = 99;
9627 TimelineEventRecorder* recorder = Timeline::recorder();
9629 IsolateTimelineEventFilter filter(isolate->main_port());
9630 recorder->PrintJSON(&js, &filter);
9631 const char* json =
js.ToCString();
9632 EXPECT_SUBSTRING(
"\"name\":\"testAsyncEvent\"", json);
9633 EXPECT_SUBSTRING(
"\"ph\":\"b\"", json);
9634 EXPECT_SUBSTRING(
"\"ts\":1000", json);
9635 EXPECT_SUBSTRING(
"\"id\":\"63\"", json);
9638#if defined(SUPPORT_PERFETTO) && !defined(PRODUCT)
9639TEST_CASE(DartAPI_TimelineAsyncInstantRace) {
9640 struct ReportAsyncEventArguments {
9641 Monitor& synchronization_monitor;
9645 Monitor synchronization_monitor;
9646 ReportAsyncEventArguments report_async_event_1_arguments{
9647 synchronization_monitor};
9648 ReportAsyncEventArguments report_async_event_2_arguments{
9649 synchronization_monitor};
9650 TimelineEventRecorder& recorder = *Timeline::recorder();
9652 TimelineEventFilter filter;
9655 TimelineStream*
stream = Timeline::GetEmbedderStream();
9657 stream->set_enabled(
true);
9663 "ReportAsyncEvent1",
9664 [](
uword arguments_ptr) {
9665 ReportAsyncEventArguments& arguments =
9666 *
reinterpret_cast<ReportAsyncEventArguments*
>(arguments_ptr);
9669 0,
nullptr,
nullptr);
9675 reinterpret_cast<uword>(&report_async_event_1_arguments));
9677 "ReportAsyncEvent2",
9678 [](
uword arguments_ptr) {
9679 ReportAsyncEventArguments& arguments =
9680 *
reinterpret_cast<ReportAsyncEventArguments*
>(arguments_ptr);
9683 0,
nullptr,
nullptr);
9689 reinterpret_cast<uword>(&report_async_event_2_arguments));
9690 recorder.PrintPerfettoTimeline(&js, filter);
9692 MonitorLocker ml(&synchronization_monitor);
9693 while (report_async_event_1_arguments.join_id ==
9695 report_async_event_2_arguments.join_id ==
9712 EXPECT_NE(micros1, micros2);
9713 EXPECT_NE(ticks1, ticks2);
9714 EXPECT_EQ(frequency1, frequency2);
9723 JSONObject obj(&js);
9724 JSONArray jstream(&obj,
"available");
9725 Timeline::PrintFlagsToJSONArray(&jstream);
9726 const char* js_str = js.ToCString();
9727#define TIMELINE_STREAM_CHECK(name, ...) EXPECT_SUBSTRING(#name, js_str);
9729#undef TIMELINE_STREAM_CHECK
9734 EXPECT_EQ(
false,
result);
9736 EXPECT_EQ(
false,
result);
9745 Timeline::PrintFlagsToJSONArray(&jstream);
9746 const char* js_str = js.ToCString();
9747 EXPECT_SUBSTRING(
"GC", js_str);
9748 EXPECT_SUBSTRING(
"API", js_str);
9749 EXPECT_SUBSTRING(
"Compiler", js_str);
9750 EXPECT_NOTSUBSTRING(
"CompilerVerbose", js_str);
9751 EXPECT_NOTSUBSTRING(
"Debugger", js_str);
9752 EXPECT_NOTSUBSTRING(
"Embedder", js_str);
9753 EXPECT_NOTSUBSTRING(
"Isolate", js_str);
9754 EXPECT_NOTSUBSTRING(
"VM", js_str);
9761 JSONObject obj(&js);
9762 JSONArray jstream(&obj,
"available");
9763 Timeline::PrintFlagsToJSONArray(&jstream);
9764 const char* js_str = js.ToCString();
9765 EXPECT_NOTSUBSTRING(
"GC", js_str);
9766 EXPECT_NOTSUBSTRING(
"API", js_str);
9767 EXPECT_NOTSUBSTRING(
"Compiler", js_str);
9768 EXPECT_NOTSUBSTRING(
"CompilerVerbose", js_str);
9769 EXPECT_NOTSUBSTRING(
"Debugger", js_str);
9770 EXPECT_NOTSUBSTRING(
"Embedder", js_str);
9771 EXPECT_SUBSTRING(
"Isolate", js_str);
9772 EXPECT_NOTSUBSTRING(
"VM", js_str);
9779 JSONObject obj(&js);
9780 JSONArray jstream(&obj,
"available");
9781 Timeline::PrintFlagsToJSONArray(&jstream);
9782 const char* js_str = js.ToCString();
9783 EXPECT_NOTSUBSTRING(
"GC", js_str);
9784 EXPECT_NOTSUBSTRING(
"API", js_str);
9785 EXPECT_NOTSUBSTRING(
"Compiler", js_str);
9786 EXPECT_NOTSUBSTRING(
"CompilerVerbose", js_str);
9787 EXPECT_NOTSUBSTRING(
"Debugger", js_str);
9788 EXPECT_NOTSUBSTRING(
"Embedder", js_str);
9789 EXPECT_NOTSUBSTRING(
"Isolate", js_str);
9790 EXPECT_NOTSUBSTRING(
"VM", js_str);
9801 bool* auto_setup_scope) {
9806 const char* kScriptChars = R
"(
9807@pragma("vm:external-name", "Test_nativeFunc")
9808external void notifyIdle();
9811 for (var i = 0; i < 100; i++) {
9813 for (var j = 0; j < 10000; j++) {
9814 t.add(List.filled(100, null));
9833 bool* auto_setup_scope) {
9838 const char* kScriptChars = R
"(
9839@pragma("vm:external-name", "Test_nativeFunc")
9840external void notifyIdle();
9843 for (var i = 0; i < 100; i++) {
9845 for (var j = 0; j < 10000; j++) {
9846 t.add(List.filled(100, null));
9866 bool* auto_setup_scope) {
9871 const char* kScriptChars = R
"(
9872import 'dart:isolate';
9873@pragma("vm:external-name", "Test_nativeFunc")
9874external void notifyDetach();
9877 for (var i = 0; i < 100; i++) {
9879 for (var j = 0; j < 10000; j++) {
9880 t.add(List.filled(100, null));
9901 bool* auto_setup_scope) {
9902 const char* cstr =
nullptr;
9904 if (strcmp(cstr,
"SetPerformanceModeDefault") == 0) {
9906 }
else if (strcmp(cstr,
"SetPerformanceModeLatency") == 0) {
9913 const char* kScriptChars = R
"(
9914import "dart:typed_data";
9915@pragma("vm:external-name", "SetPerformanceModeDefault")
9916external void setPerformanceModeDefault();
9917@pragma("vm:external-name", "SetPerformanceModeLatency")
9918external void setPerformanceModeLatency();
9920 for (var i = 0; i < 10; i++) {
9921 setPerformanceModeLatency();
9923 for (var j = 0; j < 32; j++) {
9924 t.add(Uint8List(1000000));
9926 setPerformanceModeDefault();
9943 bool* auto_setup_scope) {
9948 const char* kScriptChars = R
"(
9949import 'dart:isolate';
9950@pragma("vm:external-name", "Test_nativeFunc")
9951external void notifyLowMemory();
9954 for (var i = 0; i < 100; i++) {
9956 for (var j = 0; j < 10000; j++) {
9957 t.add(List.filled(100, null));
9974TEST_CASE(DartAPI_InvokeImportedFunction) {
9975 const char* kScriptChars =
9976 "import 'dart:math';\n"
9977 "import 'dart:developer';\n"
9987 "NoSuchMethodError: No top-level method 'max' declared.");
9993 "NoSuchMethodError: No top-level method 'getCurrentTag' declared.");
9996TEST_CASE(DartAPI_InvokeVMServiceMethod) {
10005 uint8_t* response_json = nullptr;
10006 intptr_t response_json_length = 0;
10007 char*
error =
nullptr;
10009 reinterpret_cast<uint8_t*
>(
buffer), strlen(
buffer), &response_json,
10010 &response_json_length, &
error);
10016 response_json_length, [](
void* ignored,
void* peer) { free(peer); });
10021 const char* kScript =
10023 import 'dart:convert';
10024 import 'dart:typed_data';
10025 bool validate(bool condition) {
10027 throw 'Failed to validate InvokeVMServiceMethod() response.';
10031 bool validateResult(Uint8List bytes) {
10032 final map = json.decode(utf8.decode(bytes));
10033 validate(map['jsonrpc'] == '2.0');
10034 validate(map['id'] == 'foo');
10035 validate(map['result']['name'] == 'vm');
10036 validate(map['result']['type'] == 'VM');
10037 validate(map['result'].containsKey('architectureBits'));
10038 validate(map['result'].containsKey('pid'));
10039 validate(map['result'].containsKey('startTime'));
10040 validate(map['result'].containsKey('hostCPU'));
10041 validate(map['result'].containsKey('targetCPU'));
10042 validate(map['result'].containsKey('version'));
10058#if !defined(PRODUCT)
10068 uint8_t* response_json = nullptr;
10069 intptr_t response_json_length = 0;
10070 char*
error =
nullptr;
10071 uint32_t
count = 0;
10074 response_json =
nullptr;
10075 response_json_length = 0;
10077 reinterpret_cast<uint8_t*
>(
buffer), strlen(
buffer), &response_json,
10078 &response_json_length, &
error);
10082 free(response_json);
10091 }
while (
count < 100);
10094TEST_CASE(DartAPI_InvokeVMServiceMethod_Loop) {
10106 printf(
"Response received\n");
10110 uint32_t
count = 0;
10122 }
while (
count < 100);
10135#if !defined(PRODUCT)
10137 intptr_t flow_id_count = 1;
10138 const int64_t flow_ids[1] = {123};
10152 0,
nullptr,
nullptr);
10156 0,
nullptr,
nullptr);
10163 0,
nullptr,
nullptr);
10174 0,
nullptr,
nullptr);
10183 0,
nullptr,
nullptr);
10193 0,
nullptr,
nullptr);
10199TEST_CASE(DartAPI_TimelineEvents_Serialization) {
10207 TimelineStream* stream = Timeline::GetEmbedderStream();
10209 stream->set_enabled(
true);
10212 TimelineEventRecorder* recorder = Timeline::recorder();
10213 JSONStream js_chrome_timeline;
10214 JSONStream js_perfetto_timeline;
10215 TimelineEventFilter filter;
10216 recorder->PrintJSON(&js_chrome_timeline, &filter);
10217#if defined(SUPPORT_PERFETTO)
10218 recorder->PrintPerfettoTimeline(&js_perfetto_timeline, filter);
10235 FLAG_complete_timeline =
true;
10243 params.start_kernel_isolate =
true;
10254 printf(
"VM waiting for notification\n");
10261 for (intptr_t i = 0; i < 50; i++) {
10270UNIT_TEST_CASE(DartAPI_TimelineEvents_NullFlowIdsHandledGracefully) {
10284 return reinterpret_cast<void*
>(
EchoInt);
10288 const char* kScriptChars = R
"(
10290 @Native<IntPtr Function(Double)>(symbol: 'EchoInt', isLeaf:true)
10291 external int echoInt(double x);
10292 main() => echoInt(7.0);
10306 EXPECT_EQ(7, value);
10309TEST_CASE(Dart_SetFfiNativeResolver_MissingResolver) {
10310 const char* kScriptChars = R
"(
10312 @Native<IntPtr Function(Double)>(symbol: 'EchoInt', isLeaf:true)
10313 external int echoInt(double x);
10314 main() => echoInt(7.0);
10330TEST_CASE(Dart_SetFfiNativeResolver_DoesNotResolve) {
10331 const char* kScriptChars = R
"(
10333 @Native<Void Function()>(symbol: 'DoesNotResolve')
10334 external void doesNotResolve();
10335 main() => doesNotResolve();
10351 auto default_label =
10353 EXPECT_STREQ(default_label.get(),
"Default");
10358 auto current_label =
10360 EXPECT_STREQ(default_label.get(), current_label.get());
10365 auto new_tag_label =
10367 EXPECT_STREQ(new_tag_label.get(),
"Foo");
10374 EXPECT_STREQ(old_label.get(), default_label.get());
10381 EXPECT_STREQ(current_label.get(), new_tag_label.get());
10386 "Dart_NewUserTag expects argument 'label' to be non-null");
10390 "Dart_SetCurrentUserTag expects argument 'user_tag' to be non-null");
10395#if !defined(PRODUCT) || defined(FORCE_INCLUDE_SAMPLING_HEAP_PROFILER)
10405 const char* cls_name,
10406 intptr_t heap_size) {
10408 return strdup(cls_name);
10439 TransitionNativeToVM transition(thread);
10440 thread->HandleInterrupts();
10452TEST_CASE(DartAPI_HeapSampling_UserDefinedClass) {
10453 DisableBackgroundCompilationScope scope;
10454 const char* kScriptChars = R
"(
10458 for (int i = 0; i < 100000; ++i) {
10475 void* context =
reinterpret_cast<void*
>(42);
10485TEST_CASE(DartAPI_HeapSampling_APIAllocations) {
10493 EXPECT(isolate !=
nullptr);
10499#if !defined(PRODUCT)
10510 const intptr_t kNumAllocations = 1000;
10511 for (intptr_t i = 0; i < kNumAllocations; ++i) {
10523#if !defined(PRODUCT)
10560TEST_CASE(DartAPI_HeapSampling_NonTrivialSamplingPeriod) {
10561 DisableBackgroundCompilationScope scope;
10571 const intptr_t kNumAllocations = 1000;
10572 for (intptr_t i = 0; i < kNumAllocations; ++i) {
10578 EXPECT(isolate !=
nullptr);
10589 const char* kScriptChars = R
"(
10592 for (int i = 0; i < 1000; ++i) {
10593 list.add(List.filled(100, 0));
10629 DartAPI_HeapSampling_CorrectSamplingIntervalForOldSpaceAllocations) {
10632 const char* cls_name, intptr_t allocation_size) ->
void* {
10648#if defined(DART_ENABLE_HEAP_SNAPSHOT_WRITER)
10650 struct WriterContext {
10651 intptr_t bytes_written;
10652 bool saw_last_chunk;
10655 WriterContext context = {0,
false};
10657 [](
void* context, uint8_t*
buffer, intptr_t size,
bool is_last) {
10658 auto ctx =
static_cast<WriterContext*
>(context);
10659 ctx->bytes_written +=
size;
10660 EXPECT(!ctx->saw_last_chunk);
10661 ctx->saw_last_chunk = is_last;
10667 EXPECT_GT(context.bytes_written, 0);
10668 EXPECT(context.saw_last_chunk);
static bool invalid(const SkISize &size)
static void done(const char *config, const char *src, const char *srcOptions, const char *name)
static bool equal(const SkBitmap &a, const SkBitmap &b)
static bool is_equal(SkSurface *a, SkSurface *b)
static bool contains(const SkRect &r, SkPoint p)
static bool equals(T *a, T *b)
static const size_t kBufferSize
#define FUNCTION_NAME(name)
static Dart_Handle NewHandle(Thread *thread, ObjectPtr raw)
static Dart_Isolate CastIsolate(Isolate *isolate)
static ObjectPtr UnwrapHandle(Dart_Handle object)
static Dart_Handle NewError(const char *format,...) PRINTF_ATTRIBUTE(1
static constexpr intptr_t kMaxElements
BackgroundGCTask(IsolateGroup *isolate_group, Monitor *monitor, bool *done)
uint16_t num_native_fields() const
intptr_t host_instance_size() const
static ThreadPool * thread_pool()
intptr_t Collections(Space space) const
intptr_t ExternalInWords(Space space) const
InfiniteLoopTask(Dart_Isolate *isolate, Monitor *monitor, bool *interrupted)
static IsolateGroup * Current()
ApiState * api_state() const
static Isolate * Current()
static Dart_IsolateShutdownCallback ShutdownCallback()
static void SetShutdownCallback(Dart_IsolateShutdownCallback cb)
IsolateGroup * group() const
static void SetCleanupCallback(Dart_IsolateCleanupCallback cb)
static Dart_IsolateGroupCreateCallback CreateGroupCallback()
Dart_MessageNotifyCallback message_notify_callback() const
static Dart_IsolateGroupCleanupCallback GroupCleanupCallback()
static void SetGroupCleanupCallback(Dart_IsolateGroupCleanupCallback cb)
static void SetCreateGroupCallback(Dart_IsolateGroupCreateCallback cb)
StringPtr PrivateName(const String &name) const
Monitor::WaitResult Wait(int64_t millis=Monitor::kNoTimeout)
static int Start(const char *name, ThreadStartFunction function, uword parameter)
static void Join(ThreadJoinId id)
static OSThread * Current()
static ThreadJoinId GetCurrentThreadJoinId(OSThread *thread)
static const ThreadJoinId kInvalidThreadJoinId
static void Sleep(int64_t millis)
static char * SCreate(Zone *zone, const char *format,...) PRINTF_ATTRIBUTE(2
virtual const char * ToCString() const
static constexpr intptr_t kMaxElements
static PersistentHandle * Cast(Dart_PersistentHandle handle)
static SmiPtr New(intptr_t value)
static constexpr int kPreallocatedStackdepth
bool Equals(const String &str) const
static StringPtr New(const char *cstr, Heap::Space space=Heap::kNew)
static const char * ToCString(Thread *thread, StringPtr ptr)
static void AddToKernelBuffers(const uint8_t *kernel_buffer)
static Dart_Handle LoadTestScriptWithDFE(int sourcefiles_count, Dart_SourceFile sourcefiles[], Dart_NativeEntryResolver resolver=nullptr, bool finalize=true, bool incrementally=true, bool allow_compile_errors=false, const char *entry_script_uri=nullptr, const char *multiroot_filepaths=nullptr, const char *multiroot_scheme=nullptr)
static void AddTestLib(const char *url, const char *source)
static Dart_Handle LoadTestScript(const char *script, Dart_NativeEntryResolver resolver, const char *lib_uri=RESOLVED_USER_TEST_URI, bool finalize=true, bool allow_compile_errors=false)
static char * CompileTestScriptWithDFE(const char *url, const char *source, const uint8_t **kernel_buffer, intptr_t *kernel_buffer_size, bool incrementally=true, bool allow_compile_errors=false, const char *multiroot_filepaths=nullptr, const char *multiroot_scheme=nullptr)
static const char * url()
static Dart_Handle LoadTestLibrary(const char *lib_uri, const char *script, Dart_NativeEntryResolver resolver=nullptr)
static const char * NullableTag()
static Dart_Handle library_handler(Dart_LibraryTag tag, Dart_Handle library, Dart_Handle url)
static Dart_Isolate CreateTestIsolate(const char *name=nullptr, void *isolate_group_data=nullptr, void *isolate_data=nullptr)
static Dart_IsolateShutdownCallback shutdown_callback
static Dart_IsolateGroupCreateCallback create_callback
static const char ** argv
static Dart_IsolateGroupCleanupCallback group_cleanup_callback
static const uint8_t * vm_snapshot_data
bool Run(Args &&... args)
ApiLocalScope * api_top_scope() const
static Thread * Current()
int ZoneSizeInBytes() const
intptr_t CountLocalHandles() const
static void ExitIsolateGroupAsHelper(bool bypass_safepoint)
Isolate * isolate() const
static bool EnterIsolateGroupAsHelper(IsolateGroup *isolate_group, TaskKind kind, bool bypass_safepoint)
static constexpr intptr_t kMaxElements
static TypePtr BoolType()
static TypePtr NullType()
static UnwindErrorPtr New(const String &message, Heap::Space space=Heap::kNew)
static int SNPrint(char *str, size_t size, const char *format,...) PRINTF_ATTRIBUTE(3
static char * StrDup(const char *s)
std::unique_ptr< char, decltype(std::free) * > CStringUniquePtr
static constexpr T RoundUp(T x, uintptr_t alignment, uintptr_t offset=0)
static constexpr int kSize
#define UNIT_TEST_CASE(name)
#define DART_INITIALIZE_PARAMS_CURRENT_VERSION
Dart_Isolate(* Dart_IsolateGroupCreateCallback)(const char *script_uri, const char *main, const char *package_root, const char *package_config, Dart_IsolateFlags *flags, void *isolate_data, char **error)
@ Dart_PerformanceMode_Default
@ Dart_PerformanceMode_Latency
struct _Dart_Handle * Dart_Handle
struct _Dart_Isolate * Dart_Isolate
struct _Dart_IsolateGroup * Dart_IsolateGroup
struct _Dart_NativeArguments * Dart_NativeArguments
@ Dart_TypedData_kFloat32x4
@ Dart_TypedData_kFloat32
@ Dart_TypedData_kFloat64
@ Dart_TypedData_kUint8Clamped
@ Dart_TypedData_kByteData
@ Dart_TypedData_kInvalid
Dart_Handle Dart_PersistentHandle
void(* Dart_IsolateGroupCleanupCallback)(void *isolate_group_data)
struct _Dart_FinalizableHandle * Dart_FinalizableHandle
void(* Dart_IsolateShutdownCallback)(void *isolate_group_data, void *isolate_data)
void(* Dart_NativeFunction)(Dart_NativeArguments arguments)
@ Dart_NativeArgument_kString
@ Dart_NativeArgument_kNativeFields
@ Dart_NativeArgument_kInstance
@ Dart_NativeArgument_kInt32
@ Dart_NativeArgument_kUint64
@ Dart_NativeArgument_kDouble
@ Dart_NativeArgument_kBool
struct _Dart_WeakPersistentHandle * Dart_WeakPersistentHandle
#define CHECK_API_SCOPE(thread)
#define TIMELINE_STREAM_CHECK(name,...)
@ Dart_CObject_kTypedData
@ Dart_CObject_kExternalTypedData
const EmbeddedViewParams * params
EMSCRIPTEN_KEEPALIVE void empty()
FlutterSemanticsFlag flags
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
static const uint8_t buffer[]
const uint8_t uint32_t uint32_t GError ** error
#define DECLARE_FLAG(type, name)
Dart_NativeFunction function
#define HANDLESCOPE(thread)
static float max(float r, float g, float b)
static float min(float r, float g, float b)
std::string printf(const char *fmt,...) SK_PRINTF_LIKE(1
DART_EXPORT Dart_Handle Dart_StringToUTF8(Dart_Handle str, uint8_t **utf8_array, intptr_t *length)
void CurrentStackTraceNative(Dart_NativeArguments args)
constexpr int64_t kMaxInt64
static void NewNativePort_sendInteger123(Dart_Port dest_port_id, Dart_CObject *message)
DART_EXPORT bool Dart_IsLibrary(Dart_Handle object)
static void NewNativePort_nativeReceiveInteger(Dart_Port dest_port_id, Dart_CObject *message)
static void NativeFoo4(Dart_NativeArguments args)
static void NotifyIdleShortNative(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_SetFfiNativeResolver(Dart_Handle library, Dart_FfiNativeResolver resolver)
constexpr int64_t kMinInt64
static Dart_NativeFunction native_field_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
static void * shutdown_isolate_group_data
static Dart_NativeFunction native_args_lookup(Dart_Handle name, int argument_count, bool *auto_scope_setup)
DART_EXPORT void Dart_ReportSurvivingAllocations(Dart_HeapSamplingReportCallback callback, void *context, bool force_gc)
static Dart_Handle AllocateNewString(const char *c_str)
DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index)
DART_EXPORT Dart_WeakPersistentHandle Dart_NewWeakPersistentHandle(Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static int64_t GetValue(Dart_Handle arg)
DART_EXPORT Dart_Handle Dart_ClassLibrary(Dart_Handle cls_type)
static void * HeapSamplingCreate(Dart_Isolate isolate, Dart_IsolateGroup isolate_group, const char *cls_name, intptr_t heap_size)
DART_EXPORT Dart_Handle Dart_SetPeer(Dart_Handle object, void *peer)
static Dart_NativeFunction PropagateError_native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT bool Dart_IsDouble(Dart_Handle object)
DART_EXPORT bool Dart_IsInstance(Dart_Handle object)
DART_EXPORT void Dart_DisableHeapSampling()
DART_EXPORT Dart_Handle Dart_IsNonNullableType(Dart_Handle type, bool *result)
static void FinalizableHandlePeerFinalizer(void *isolate_callback_data, void *peer)
static const char * last_allocation_cls
DART_EXPORT Dart_Handle Dart_SetCurrentUserTag(Dart_Handle user_tag)
constexpr intptr_t kMicrosecondsPerMillisecond
DART_EXPORT bool Dart_IsCompilationError(Dart_Handle object)
void ResetHeapSamplingState(const char *expected_cls=nullptr)
static void IsolateShutdownTestCallback(void *group_data, void *isolate_data)
static void NativeArgumentAccess(Dart_NativeArguments args)
static void DeleteWeakHandleOnFinalization(void *isolate_callback_data, void *peer)
static void FinalizableHandlePeerCleanupFinalizer(void *isolate_callback_data, void *peer)
static void NotifyLowMemoryNative(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_Allocate(Dart_Handle type)
static void MyNativeFunction1(Dart_NativeArguments args)
DART_EXPORT bool Dart_IsBoolean(Dart_Handle object)
Dart_Handle Dart_StackTraceLength(Dart_StackTrace trace, intptr_t *length)
static void SetPerformanceModeLatency(Dart_NativeArguments args)
DART_EXPORT void Dart_EnterScope()
DART_EXPORT bool Dart_IsStringLatin1(Dart_Handle object)
static void * last_allocation_context
DART_EXPORT void Dart_SetPersistentHandle(Dart_PersistentHandle obj1, Dart_Handle obj2)
static void NewNativePort_Transferrable1(Dart_Port dest_port_id, Dart_CObject *message)
Dart_Handle Dart_ActivationFrameInfo(Dart_ActivationFrame activation_frame, Dart_Handle *function_name, Dart_Handle *script_url, intptr_t *line_number, intptr_t *column_number)
DART_EXPORT Dart_Port Dart_GetMainPortId()
DART_EXPORT Dart_Handle Dart_FinalizeLoading(bool complete_futures)
DART_EXPORT Dart_Handle Dart_NewUserTag(const char *label)
DART_EXPORT Dart_Handle Dart_GetStickyError()
static void ExternalTypedDataAccessTests(Dart_Handle obj, Dart_TypedData_Type expected_type, uint8_t data[], intptr_t data_length)
DART_EXPORT char * Dart_GetUserTagLabel(Dart_Handle user_tag)
void NativeFieldLookup(Dart_NativeArguments args)
DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle)
static void ExternalByteDataNativeFunction(Dart_NativeArguments args)
DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate)
void PropagateErrorNative(Dart_NativeArguments args)
static Dart_NativeFunction SetMode_native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT Dart_Handle Dart_TypeNever()
static bool byte_data_finalizer_run
DART_EXPORT Dart_Handle Dart_DebugName()
DART_EXPORT Dart_Handle Dart_False()
DART_EXPORT bool Dart_ErrorHasException(Dart_Handle handle)
static void * SecretKeeperFfiNativeResolver(const char *name, uintptr_t argn)
DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj, int index, intptr_t *value)
DART_EXPORT Dart_Handle Dart_NewStringFromUTF32(const int32_t *utf32_array, intptr_t length)
DART_EXPORT Dart_Handle Dart_Invoke(Dart_Handle target, Dart_Handle name, int number_of_arguments, Dart_Handle *arguments)
static Dart_NativeFunction MyNativeResolver1(Dart_Handle name, int arg_count, bool *auto_setup_scope)
static void SlowWeakPersistentHandle(void *isolate_callback_data, void *peer)
DART_EXPORT Dart_Handle Dart_NewDouble(double value)
Dart_Handle Dart_GetStackTrace(Dart_StackTrace *trace)
DART_EXPORT const char * Dart_IsolateServiceId(Dart_Isolate isolate)
static void UnreachedCallback(void *isolate_callback_data, void *peer)
static void * cleanup_isolate_data
Dart_WeakPersistentHandle delete_on_finalization
DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle cls_type)
DART_EXPORT Dart_Handle Dart_GetPeer(Dart_Handle object, void **peer)
static Dart_WeakPersistentHandle weak3
static void TestFieldOk(Dart_Handle container, Dart_Handle name, bool final, const char *initial_value)
static void StaticNativeFoo4(Dart_NativeArguments args)
DART_EXPORT bool Dart_HasStickyError()
DART_EXPORT Dart_Handle Dart_StringToLatin1(Dart_Handle str, uint8_t *latin1_array, intptr_t *length)
DART_EXPORT void Dart_NotifyLowMemory()
static Dart_WeakPersistentHandle weak1
DART_EXPORT Dart_Handle Dart_True()
DART_EXPORT Dart_Handle Dart_RootLibrary()
DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library, Dart_Handle class_name)
DART_EXPORT bool Dart_IsNumber(Dart_Handle object)
static void CreateTimelineEvents(uword param)
static bool use_set_return
DART_EXPORT Dart_Handle Dart_NewStringFromUTF16(const uint16_t *utf16_array, intptr_t length)
static void IsolateGroupCleanupTestCallback(void *callback_data)
DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer, bool *fits)
DART_EXPORT Dart_Handle Dart_GetNativeInstanceFieldCount(Dart_Handle obj, int *count)
void * malloc(size_t size)
static void WeakPersistentHandlePeerCleanupFinalizer(void *isolate_callback_data, void *peer)
void TestNativeFieldsAccess_access(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_GetDefaultUserTag()
DART_EXPORT Dart_Handle Dart_TypeDynamic()
static void MyMessageNotifyCallback(Dart_Isolate dest_isolate)
DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception)
static intptr_t kNativeArgumentNativeField1Value
static void NativeFoo1(Dart_NativeArguments args)
static void StaticNativeFoo1(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value)
DART_EXPORT bool Dart_IsUnhandledExceptionError(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj, bool *value)
static Dart_NativeFunction NotifyIdleLong_native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
static intptr_t EchoInt(double x)
DART_EXPORT Dart_Handle Dart_NewExternalTypedDataWithFinalizer(Dart_TypedData_Type type, void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
static Dart_NativeFunction ExternalByteDataNativeResolver(Dart_Handle name, int arg_count, bool *auto_setup_scope)
static void NotifyDestroyedNative(Dart_NativeArguments args)
static void NotifyIdleLongNative(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_NewStringFromUTF8(const uint8_t *utf8_array, intptr_t length)
DART_EXPORT void Dart_PropagateError(Dart_Handle handle)
static void NewNativePort_send123(Dart_Port dest_port_id, Dart_CObject *message)
static Dart_WeakPersistentHandle weak_persistent_handle2
constexpr uint64_t kMaxUint64
static Dart_NativeFunction MyNativeClosureResolver(Dart_Handle name, int arg_count, bool *auto_setup_scope)
static void ReportTimelineEvents()
static void HandleResponse(Dart_Port dest_port_id, Dart_CObject *message)
DART_EXPORT void * Dart_IsolateGroupData(Dart_Isolate isolate)
DART_EXPORT Dart_Handle Dart_GetNonNullableType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT Dart_FinalizableHandle Dart_NewFinalizableHandle(Dart_Handle object, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT const char * Dart_GetError(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_NewTypedData(Dart_TypedData_Type type, intptr_t length)
DART_EXPORT Dart_Handle Dart_HandleFromWeakPersistent(Dart_WeakPersistentHandle object)
DART_EXPORT Dart_IsolateGroup Dart_CurrentIsolateGroup()
void TestNativeFieldsAccess_init(Dart_NativeArguments args)
DART_EXPORT uint8_t * Dart_ScopeAllocate(intptr_t size)
DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args, Dart_Handle retval)
static void NewNativePort_Transferrable2(Dart_Port dest_port_id, Dart_CObject *message)
DART_EXPORT Dart_Handle Dart_GetStaticMethodClosure(Dart_Handle library, Dart_Handle cls_type, Dart_Handle function_name)
DART_EXPORT void Dart_RecordTimelineEvent(const char *label, int64_t timestamp0, int64_t timestamp1_or_id, intptr_t flow_id_count, const int64_t *flow_ids, Dart_Timeline_Event_Type type, intptr_t argument_count, const char **argument_names, const char **argument_values)
const intptr_t kDefaultNewGenSemiMaxSize
DART_EXPORT void Dart_NotifyDestroyed()
static intptr_t heap_samples
static void RunLoopTest(bool throw_exception)
static void IsolateShutdownRunDartCodeTestCallback(void *isolate_group_data, void *isolate_data)
DART_EXPORT char * Dart_Initialize(Dart_InitializeParams *params)
static int64_t add_result
DART_EXPORT Dart_Handle Dart_GetField(Dart_Handle container, Dart_Handle name)
void JustPropagateErrorNative(Dart_NativeArguments args)
static constexpr intptr_t kSendLength
DART_EXPORT Dart_Handle Dart_IsNullableType(Dart_Handle type, bool *result)
DART_EXPORT Dart_Handle Dart_GetCurrentUserTag()
static void * FfiNativeResolver(const char *name, uintptr_t args_n)
DART_EXPORT Dart_Handle Dart_MapGetAt(Dart_Handle map, Dart_Handle key)
DART_EXPORT Dart_Handle Dart_FunctionIsStatic(Dart_Handle function, bool *is_static)
DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char *str)
DART_EXPORT void Dart_SetHeapSamplingPeriod(intptr_t bytes)
DART_EXPORT int64_t Dart_TimelineGetTicks()
static void StaticNativeFoo2(Dart_NativeArguments args)
DART_EXPORT bool Dart_IsFuture(Dart_Handle handle)
DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_ClosureFunction(Dart_Handle closure)
static Dart_NativeFunction native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
static void UnreachableMessageHandler(Dart_Port dest_port_id, Dart_CObject *message)
void TestNativeFieldsAccess_invalidAccess(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object, Dart_TypedData_Type *type, void **data, intptr_t *len)
DART_EXPORT Dart_Handle Dart_GetNullableType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
static void StaticNativeFoo3(Dart_NativeArguments args)
DART_EXPORT Dart_Isolate Dart_CurrentIsolate()
static void OptExternalByteDataNativeFunction(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_NewListOfTypeFilled(Dart_Handle element_type, Dart_Handle fill_object, intptr_t length)
static Dart_FinalizableHandle finalizable_handle3
DART_EXPORT Dart_Handle Dart_InvokeConstructor(Dart_Handle object, Dart_Handle name, int number_of_arguments, Dart_Handle *arguments)
DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list, intptr_t index, Dart_Handle value)
DART_EXPORT char * Dart_WriteHeapSnapshot(Dart_HeapSnapshotWriteChunkCallback write, void *context)
static Dart_Handle AsHandle(Dart_PersistentHandle weak)
DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer, const char **value)
static constexpr intptr_t kExtLength
DART_EXPORT bool Dart_SetEnabledTimelineCategory(const char *categories)
DART_EXPORT Dart_Handle Dart_FunctionName(Dart_Handle function)
DART_EXPORT bool Dart_IsKernelIsolate(Dart_Isolate isolate)
struct _Dart_ActivationFrame * Dart_ActivationFrame
void FUNCTION_NAME() SecretKeeper_KeepSecret(Dart_NativeArguments native_args)
static void MyNativeFunction2(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_NewBoolean(bool value)
DART_EXPORT char * Dart_Cleanup()
static Dart_NativeFunction NotifyIdleShort_native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT void Dart_DeletePersistentHandle(Dart_PersistentHandle object)
DART_EXPORT bool Dart_IsError(Dart_Handle handle)
static Monitor * loop_test_lock
static constexpr int kTestNumNativeFields
DART_EXPORT Dart_Handle Dart_SetNativeInstanceField(Dart_Handle obj, int index, intptr_t value)
DART_EXPORT void Dart_SetIntegerReturnValue(Dart_NativeArguments args, int64_t retval)
DART_EXPORT void Dart_DeleteWeakPersistentHandle(Dart_WeakPersistentHandle object)
static Dart_NativeFunction MyNativeResolver2(Dart_Handle name, int arg_count, bool *auto_setup_scope)
DART_EXPORT Dart_Handle Dart_EmptyString()
static void NativeArgumentCreate(Dart_NativeArguments args)
static void NopCallback(void *isolate_callback_data, void *peer)
static Dart_NativeFunction MyStaticNativeClosureResolver(Dart_Handle name, int arg_count, bool *auto_setup_scope)
DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id)
DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object, Dart_Handle type, bool *value)
DART_EXPORT Dart_Handle Dart_CopyUTF8EncodingOfString(Dart_Handle str, uint8_t *utf8_array, intptr_t length)
DART_EXPORT Dart_Handle Dart_ErrorGetStackTrace(Dart_Handle handle)
static void FinalizeTypedData(void *isolate_callback_data, void *peer)
DART_EXPORT Dart_Handle Dart_TypeToNullableType(Dart_Handle type)
DART_EXPORT Dart_Handle Dart_GetNativeFieldsOfArgument(Dart_NativeArguments args, int arg_index, int num_fields, intptr_t *field_values)
Dart_Handle Dart_GetActivationFrame(Dart_StackTrace trace, int frame_index, Dart_ActivationFrame *frame)
static bool found_allocation
DART_EXPORT Dart_PerformanceMode Dart_SetPerformanceMode(Dart_PerformanceMode mode)
DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list, intptr_t offset, const uint8_t *native_array, intptr_t length)
static void TestTypedDataDirectAccess()
static Dart_Handle AllocateOldString(const char *c_str)
static Dart_NativeFunction ByteDataNativeResolver(Dart_Handle name, int arg_count, bool *auto_setup_scope)
static void TestDirectAccess(Dart_Handle lib, Dart_Handle array, Dart_TypedData_Type expected_type, bool is_external)
static Dart_NativeFunction CurrentStackTraceNativeLookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
static Dart_NativeFunction TestNativeFieldsAccess_lookup(Dart_Handle name, int argument_count, bool *auto_scope)
DART_EXPORT Dart_Handle Dart_NewExternalTypedData(Dart_TypedData_Type type, void *data, intptr_t length)
static void HeapSamplingDelete(void *data)
DART_EXPORT Dart_Handle Dart_TypeToNonNullableType(Dart_Handle type)
DART_EXPORT Dart_Handle Dart_AllocateWithNativeFields(Dart_Handle type, intptr_t num_native_fields, const intptr_t *native_fields)
DART_EXPORT Dart_Handle Dart_IntegerToUint64(Dart_Handle integer, uint64_t *value)
DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfTypedData(Dart_Handle object)
DART_EXPORT bool Dart_InvokeVMServiceMethod(uint8_t *request_json, intptr_t request_json_length, uint8_t **response_json, intptr_t *response_json_length, char **error)
DART_EXPORT Dart_Handle Dart_FunctionOwner(Dart_Handle function)
DART_EXPORT Dart_Handle Dart_StringGetProperties(Dart_Handle object, intptr_t *char_size, intptr_t *str_len, void **peer)
DART_EXPORT Dart_Handle Dart_NewIntegerFromUint64(uint64_t value)
DART_EXPORT bool Dart_IsServiceIsolate(Dart_Isolate isolate)
static void WeakPersistentHandlePeerCleanupEnsuresIGFinalizer(void *isolate_callback_data, void *peer)
static void NewNativePort_ExternalTypedData(Dart_Port dest_port_id, Dart_CObject *message)
DART_EXPORT bool Dart_IsMap(Dart_Handle object)
static void NewNativePort_sendInteger321(Dart_Port dest_port_id, Dart_CObject *message)
DART_EXPORT Dart_Handle Dart_SetNativeResolver(Dart_Handle library, Dart_NativeEntryResolver resolver, Dart_NativeEntrySymbol symbol)
static constexpr intptr_t kNativeField1Value
DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj, double *value)
DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args, int index)
static Dart_PersistentHandle persistent_handle1
static void * finalizable_old_ref_peer
DART_EXPORT void Dart_ExitIsolate()
static bool loop_test_exit
DART_EXPORT bool Dart_IsFunction(Dart_Handle handle)
DART_EXPORT char * Dart_IsolateMakeRunnable(Dart_Isolate isolate)
static void CreateNativePorts(uword param)
static void NewNativePort_nativeReceiveNull(Dart_Port dest_port_id, Dart_CObject *message)
static Dart_FinalizableHandle finalizable_old_ref
static Dart_NativeFunction NotifyDestroyed_native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance)
DART_EXPORT bool Dart_CloseNativePort(Dart_Port native_port_id)
static void NativeFoo2(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_NewByteBuffer(Dart_Handle typed_data)
DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container, Dart_Handle name, Dart_Handle value)
DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t *len)
static void TestByteDataDirectAccess()
Dart_Handle NewString(const char *str)
static void * finalizable_new_ref_peer
DART_EXPORT bool Dart_IsTearOff(Dart_Handle object)
static Dart_Isolate RunLoopTestCallback(const char *script_name, const char *main, const char *package_root, const char *package_config, Dart_IsolateFlags *flags, void *data, char **error)
static void NativeArgumentCounter(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list, intptr_t offset, uint8_t *native_array, intptr_t length)
void HandleInterrupts(Thread *thread)
static void SlowFinalizer(void *isolate_callback_data, void *peer)
DART_EXPORT Dart_Handle Dart_RunLoop()
DART_EXPORT void * Dart_CurrentIsolateGroupData()
DART_EXPORT Dart_Handle Dart_NewListOfType(Dart_Handle element_type, intptr_t length)
static void CheckFloat32x4Data(Dart_Handle obj)
DART_EXPORT bool Dart_IsType(Dart_Handle handle)
static Dart_WeakPersistentHandle weak_persistent_handle3
DART_EXPORT Dart_Handle Dart_MapKeys(Dart_Handle map)
static void TestTypedDataDirectAccess1()
DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure, int number_of_arguments, Dart_Handle *arguments)
Dart_Handle Dart_GetStackTraceFromError(Dart_Handle handle, Dart_StackTrace *trace)
DART_EXPORT char * Dart_SetVMFlags(int argc, const char **argv)
DART_EXPORT void Dart_NotifyIdle(int64_t deadline)
DART_EXPORT Dart_Handle Dart_NewListOf(Dart_CoreType_Id element_type_id, intptr_t length)
void InitHeapSampling(Thread *thread, const char *expected_cls)
static int8_t opt_data[kOptExtLength]
static void * NopResolver(const char *name, uintptr_t args_n)
DART_EXPORT void Dart_DeleteFinalizableHandle(Dart_FinalizableHandle object, Dart_Handle strong_ref_to_object)
DART_EXPORT Dart_Handle Dart_SetLibraryTagHandler(Dart_LibraryTagHandler handler)
static const char * expected_allocation_cls
static Dart_Handle LoadScript(const char *url_str, const char *source)
DART_EXPORT Dart_Handle Dart_TypeVoid()
DART_EXPORT Dart_Handle Dart_MapContainsKey(Dart_Handle map, Dart_Handle key)
DART_EXPORT Dart_Handle Dart_TypedDataReleaseData(Dart_Handle object)
DART_EXPORT void Dart_ExitScope()
DART_EXPORT int64_t Dart_TimelineGetTicksFrequency()
static void UnreachableFinalizer(void *isolate_callback_data, void *peer)
static intptr_t kNativeArgumentNativeField2Value
DART_EXPORT void Dart_RegisterHeapSamplingCallback(Dart_HeapSamplingCreateCallback create_callback, Dart_HeapSamplingDeleteCallback delete_callback)
DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfExternalTypedData(Dart_Handle object)
static void FinalizableHandleCallback(void *isolate_callback_data, void *peer)
DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer, bool *fits)
static void WeakPersistentHandlePeerFinalizer(void *isolate_callback_data, void *peer)
DART_EXPORT Dart_Handle Dart_NewApiError(const char *error)
DART_EXPORT Dart_Handle Dart_ListGetRange(Dart_Handle list, intptr_t offset, intptr_t length, Dart_Handle *result)
DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t *len)
DART_EXPORT void Dart_SetMessageNotifyCallback(Dart_MessageNotifyCallback message_notify_callback)
DART_EXPORT Dart_Handle Dart_NewList(intptr_t length)
void ExceptionNative(Dart_NativeArguments args)
static Dart_Handle PrivateLibName(Dart_Handle lib, const char *str)
static Dart_NativeFunction NotifyLowMemory_native_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
constexpr intptr_t kWordSize
static void * cleanup_isolate_group_data
DART_EXPORT void Dart_KillIsolate(Dart_Isolate handle)
DART_EXPORT Dart_Handle Dart_NewCompilationError(const char *error)
DART_EXPORT Dart_Handle Dart_GetNativeDoubleArgument(Dart_NativeArguments args, int index, double *value)
DART_EXPORT Dart_Handle Dart_ErrorGetException(Dart_Handle handle)
static void TestUnmodifiableTypedDataViewDirectAccess()
DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url)
static constexpr intptr_t kObjectAlignment
DART_EXPORT bool Dart_IsList(Dart_Handle object)
static Dart_NativeFunction SecretKeeperNativeResolver(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT bool Dart_IsApiError(Dart_Handle object)
static void NativeFoo3(Dart_NativeArguments args)
DART_EXPORT void * Dart_CurrentIsolateData()
static void TestNativeFields(Dart_Handle retobj)
DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception)
static void ByteDataNativeFunction(Dart_NativeArguments args)
DART_EXPORT Dart_Handle Dart_GetNativeIntegerArgument(Dart_NativeArguments args, int index, int64_t *value)
DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args)
struct _Dart_StackTrace * Dart_StackTrace
DART_EXPORT Dart_Handle Dart_LoadScriptFromKernel(const uint8_t *buffer, intptr_t buffer_size)
DART_EXPORT bool Dart_IsInteger(Dart_Handle object)
static intptr_t ReturnPtrAsInt(void *ptr)
static constexpr intptr_t kOptExtLength
DART_EXPORT int64_t Dart_TimelineGetMicros()
DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2, bool *value)
DART_EXPORT bool Dart_IsNull(Dart_Handle object)
static void NewNativePort_send321(Dart_Port dest_port_id, Dart_CObject *message)
DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library)
DART_EXPORT Dart_Port Dart_NewNativePort(const char *name, Dart_NativeMessageHandler handler, bool handle_concurrently)
DART_EXPORT bool Dart_IsTypedData(Dart_Handle handle)
DART_EXPORT bool Dart_PostCObject(Dart_Port port_id, Dart_CObject *message)
DART_EXPORT Dart_Handle Dart_Null()
void HeapSamplingReport(void *context, void *data)
static void SetPerformanceModeDefault(Dart_NativeArguments args)
static bool use_throw_exception
static Dart_NativeFunction OptExternalByteDataNativeResolver(Dart_Handle name, int arg_count, bool *auto_setup_scope)
DART_EXPORT void Dart_SetStickyError(Dart_Handle error)
DART_EXPORT bool Dart_IsString(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_New(Dart_Handle type, Dart_Handle constructor_name, int number_of_arguments, Dart_Handle *arguments)
const char *const function_name
static int8_t data[kExtLength]
static void TestTypedDataViewDirectAccess()
static Dart_NativeFunction gnac_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT Dart_Handle Dart_SetRootLibrary(Dart_Handle library)
DART_EXPORT Dart_Handle Dart_GetNativeBooleanArgument(Dart_NativeArguments args, int index, bool *value)
static void TestFieldNotFound(Dart_Handle container, Dart_Handle name)
DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object, const char **cstr)
DART_EXPORT Dart_Handle Dart_HandleFromPersistent(Dart_PersistentHandle object)
DART_EXPORT Dart_Handle Dart_GetType(Dart_Handle library, Dart_Handle class_name, intptr_t number_of_type_arguments, Dart_Handle *type_arguments)
DART_EXPORT void Dart_ShutdownIsolate()
DART_EXPORT bool Dart_IsClosure(Dart_Handle object)
static void DontDeleteWeakHandleOnFinalization(void *isolate_callback_data, void *peer)
static void * cleanup_group_callback_data
DART_EXPORT Dart_Handle Dart_NewUnmodifiableExternalTypedDataWithFinalizer(Dart_TypedData_Type type, const void *data, intptr_t length, void *peer, intptr_t external_allocation_size, Dart_HandleFinalizer callback)
DART_EXPORT Dart_Handle Dart_GetDataFromByteBuffer(Dart_Handle object)
void ByteDataFinalizer(void *isolate_data, void *peer)
DART_EXPORT bool Dart_PostInteger(Dart_Port port_id, int64_t message)
DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char *str)
static void ExternalTypedDataFinalizer(void *isolate_callback_data, void *peer)
DART_EXPORT Dart_PersistentHandle Dart_NewPersistentHandle(Dart_Handle object)
DART_EXPORT Dart_Handle Dart_GetNativeArguments(Dart_NativeArguments args, int num_arguments, const Dart_NativeArgument_Descriptor *argument_descriptors, Dart_NativeArgument_Value *arg_values)
static Dart_NativeFunction JustPropagateError_lookup(Dart_Handle name, int argument_count, bool *auto_setup_scope)
DART_EXPORT bool Dart_IsByteBuffer(Dart_Handle handle)
static void InvokeServiceMessages(uword param)
void VerifyStackOverflowStackTraceInfo(const char *script, const char *top_frame_func_name, const char *entry_func_name, int expected_line_number, int expected_column_number)
const intptr_t kMaxAddrSpaceMB
DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2)
static void * shutdown_isolate_data
DART_EXPORT bool Dart_IsFatalError(Dart_Handle object)
static Dart_WeakPersistentHandle weak2
DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer, int64_t *value)
static void IsolateCleanupTestCallback(void *group_data, void *isolate_data)
DART_EXPORT Dart_Handle Dart_StringUTF8Length(Dart_Handle str, intptr_t *len)
static bool loop_reset_count
static void ImplicitReferencesCallback(void *isolate_callback_data, void *peer)
static Dart_FinalizableHandle finalizable_new_ref
DART_EXPORT Dart_Handle Dart_IsLegacyType(Dart_Handle type, bool *result)
DART_EXPORT void Dart_EnableHeapSampling()
static constexpr intptr_t kNativeField2Value
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Dart_OnNewCodeCallback on_new_code
union _Dart_CObject::@86 value
struct _Dart_CObject::@86::@90 as_typed_data
struct _Dart_CObject::@86::@89 as_array
struct _Dart_CObject ** values
struct _Dart_NativeArgument_Value::@84 as_native_fields
#define VM_UNIT_TEST_CASE(name)
#define ZONE_STR(FMT,...)
#define EXPECT_ERROR(handle, substring)
#define RESOLVED_USER_TEST_URI
#define EXPECT_VALID(handle)
#define ARRAY_SIZE(array)