2018-06-11 11:01:35 -04:00
|
|
|
// Copyright 2018 Ryan Dahl <ry@tinyclouds.org>
|
|
|
|
// All rights reserved. MIT License.
|
|
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
|
2018-07-06 03:19:19 -04:00
|
|
|
#include "deno.h"
|
2018-06-11 11:01:35 -04:00
|
|
|
|
|
|
|
TEST(MockRuntimeTest, InitializesCorrectly) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-06-11 14:49:57 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "1 + 2"));
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 11:01:35 -04:00
|
|
|
}
|
|
|
|
|
2018-06-11 15:30:58 -04:00
|
|
|
TEST(MockRuntimeTest, CanCallFunction) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-06-11 15:30:58 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js",
|
|
|
|
"if (CanCallFunction() != 'foo') throw Error();"));
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 11:01:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(MockRuntimeTest, ErrorsCorrectly) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-06-11 14:49:57 -04:00
|
|
|
EXPECT_FALSE(deno_execute(d, "a.js", "throw Error()"));
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 11:01:35 -04:00
|
|
|
}
|
|
|
|
|
2018-07-08 21:35:34 -04:00
|
|
|
deno_buf strbuf(const char* str) {
|
|
|
|
auto len = strlen(str);
|
|
|
|
|
|
|
|
deno_buf buf;
|
|
|
|
buf.alloc_ptr = reinterpret_cast<uint8_t*>(strdup(str));
|
|
|
|
buf.alloc_len = len + 1;
|
|
|
|
buf.data_ptr = buf.alloc_ptr;
|
|
|
|
buf.data_len = len;
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
2018-06-11 12:17:28 -04:00
|
|
|
|
2018-07-01 12:07:12 -04:00
|
|
|
TEST(MockRuntimeTest, SendSuccess) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-07-01 12:07:12 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "SendSuccess()"));
|
2018-07-06 16:26:34 -04:00
|
|
|
EXPECT_TRUE(deno_send(d, strbuf("abc")));
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 12:17:28 -04:00
|
|
|
}
|
|
|
|
|
2018-07-01 12:07:12 -04:00
|
|
|
TEST(MockRuntimeTest, SendByteLength) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-07-01 12:07:12 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "SendByteLength()"));
|
2018-06-11 13:18:53 -04:00
|
|
|
// We pub the wrong sized message, it should throw.
|
2018-07-06 16:26:34 -04:00
|
|
|
EXPECT_FALSE(deno_send(d, strbuf("abcd")));
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 12:17:28 -04:00
|
|
|
}
|
|
|
|
|
2018-07-01 12:07:12 -04:00
|
|
|
TEST(MockRuntimeTest, SendNoCallback) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-07-01 12:07:12 -04:00
|
|
|
// We didn't call deno.recv() in JS, should fail.
|
2018-07-06 16:26:34 -04:00
|
|
|
EXPECT_FALSE(deno_send(d, strbuf("abc")));
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 12:17:28 -04:00
|
|
|
}
|
|
|
|
|
2018-07-01 12:07:12 -04:00
|
|
|
TEST(MockRuntimeTest, RecvReturnEmpty) {
|
2018-06-11 14:18:56 -04:00
|
|
|
static int count = 0;
|
2018-07-06 16:26:34 -04:00
|
|
|
Deno* d = deno_new(nullptr, [](auto _, auto buf) {
|
2018-06-11 14:18:56 -04:00
|
|
|
count++;
|
2018-07-08 21:35:34 -04:00
|
|
|
EXPECT_EQ(static_cast<size_t>(3), buf.data_len);
|
|
|
|
EXPECT_EQ(buf.data_ptr[0], 'a');
|
|
|
|
EXPECT_EQ(buf.data_ptr[1], 'b');
|
|
|
|
EXPECT_EQ(buf.data_ptr[2], 'c');
|
2018-06-11 14:18:56 -04:00
|
|
|
});
|
2018-07-01 12:07:12 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "RecvReturnEmpty()"));
|
2018-06-11 14:18:56 -04:00
|
|
|
EXPECT_EQ(count, 2);
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 14:18:56 -04:00
|
|
|
}
|
|
|
|
|
2018-07-01 12:07:12 -04:00
|
|
|
TEST(MockRuntimeTest, RecvReturnBar) {
|
2018-06-11 14:18:56 -04:00
|
|
|
static int count = 0;
|
2018-07-06 16:26:34 -04:00
|
|
|
Deno* d = deno_new(nullptr, [](auto deno, auto buf) {
|
2018-06-11 14:18:56 -04:00
|
|
|
count++;
|
2018-07-08 21:35:34 -04:00
|
|
|
EXPECT_EQ(static_cast<size_t>(3), buf.data_len);
|
|
|
|
EXPECT_EQ(buf.data_ptr[0], 'a');
|
|
|
|
EXPECT_EQ(buf.data_ptr[1], 'b');
|
|
|
|
EXPECT_EQ(buf.data_ptr[2], 'c');
|
2018-06-13 13:38:22 -04:00
|
|
|
deno_set_response(deno, strbuf("bar"));
|
2018-06-11 14:18:56 -04:00
|
|
|
});
|
2018-07-01 12:07:12 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "RecvReturnBar()"));
|
2018-06-11 14:18:56 -04:00
|
|
|
EXPECT_EQ(count, 1);
|
2018-06-11 16:36:14 -04:00
|
|
|
deno_delete(d);
|
2018-06-11 14:18:56 -04:00
|
|
|
}
|
|
|
|
|
2018-07-01 12:07:12 -04:00
|
|
|
TEST(MockRuntimeTest, DoubleRecvFails) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-07-01 12:07:12 -04:00
|
|
|
EXPECT_FALSE(deno_execute(d, "a.js", "DoubleRecvFails()"));
|
2018-06-11 16:51:11 -04:00
|
|
|
deno_delete(d);
|
|
|
|
}
|
|
|
|
|
2018-07-08 21:35:34 -04:00
|
|
|
TEST(MockRuntimeTest, SendRecvSlice) {
|
|
|
|
static int count = 0;
|
|
|
|
Deno* d = deno_new(nullptr, [](auto deno, auto buf) {
|
|
|
|
static const size_t alloc_len = 1024;
|
|
|
|
size_t i = count++;
|
|
|
|
// Check the size and offset of the slice.
|
|
|
|
size_t data_offset = buf.data_ptr - buf.alloc_ptr;
|
|
|
|
EXPECT_EQ(data_offset, i * 11);
|
|
|
|
EXPECT_EQ(buf.data_len, alloc_len - i * 30);
|
|
|
|
EXPECT_EQ(buf.alloc_len, alloc_len);
|
|
|
|
// Check values written by the JS side.
|
|
|
|
EXPECT_EQ(buf.data_ptr[0], 100 + i);
|
|
|
|
EXPECT_EQ(buf.data_ptr[buf.data_len - 1], 100 - i);
|
|
|
|
// Make copy of the backing buffer -- this is currently necessary because
|
|
|
|
// deno_set_response() takes ownership over the buffer, but we are not given
|
|
|
|
// ownership of `buf` by our caller.
|
|
|
|
uint8_t* alloc_ptr = reinterpret_cast<uint8_t*>(malloc(alloc_len));
|
|
|
|
memcpy(alloc_ptr, buf.alloc_ptr, alloc_len);
|
|
|
|
// Make a slice that is a bit shorter than the original.
|
|
|
|
deno_buf buf2{alloc_ptr, alloc_len, alloc_ptr + data_offset,
|
|
|
|
buf.data_len - 19};
|
|
|
|
// Place some values into the buffer for the JS side to verify.
|
|
|
|
buf2.data_ptr[0] = 200 + i;
|
|
|
|
buf2.data_ptr[buf2.data_len - 1] = 200 - i;
|
|
|
|
// Send back.
|
|
|
|
deno_set_response(deno, buf2);
|
|
|
|
});
|
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "SendRecvSlice()"));
|
|
|
|
EXPECT_EQ(count, 5);
|
|
|
|
deno_delete(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(MockRuntimeTest, JSSendArrayBufferViewTypes) {
|
|
|
|
static int count = 0;
|
|
|
|
Deno* d = deno_new(nullptr, [](auto _, auto buf) {
|
|
|
|
count++;
|
|
|
|
size_t data_offset = buf.data_ptr - buf.alloc_ptr;
|
|
|
|
EXPECT_EQ(data_offset, 2468);
|
|
|
|
EXPECT_EQ(buf.data_len, 1000);
|
|
|
|
EXPECT_EQ(buf.alloc_len, 4321);
|
|
|
|
EXPECT_EQ(buf.data_ptr[0], count);
|
|
|
|
});
|
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "JSSendArrayBufferViewTypes()"));
|
|
|
|
EXPECT_EQ(count, 3);
|
|
|
|
deno_delete(d);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(MockRuntimeTest, JSSendNeutersBuffer) {
|
|
|
|
static int count = 0;
|
|
|
|
Deno* d = deno_new(nullptr, [](auto _, auto buf) {
|
|
|
|
count++;
|
|
|
|
EXPECT_EQ(buf.data_len, 1);
|
|
|
|
EXPECT_EQ(buf.data_ptr[0], 42);
|
|
|
|
});
|
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "JSSendNeutersBuffer()"));
|
|
|
|
EXPECT_EQ(count, 1);
|
|
|
|
deno_delete(d);
|
|
|
|
}
|
|
|
|
|
2018-06-12 00:36:01 -04:00
|
|
|
TEST(MockRuntimeTest, TypedArraySnapshots) {
|
2018-06-13 13:38:22 -04:00
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
2018-06-12 00:36:01 -04:00
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "TypedArraySnapshots()"));
|
|
|
|
deno_delete(d);
|
|
|
|
}
|
|
|
|
|
2018-06-18 09:55:36 -04:00
|
|
|
TEST(MockRuntimeTest, SnapshotBug) {
|
|
|
|
Deno* d = deno_new(nullptr, nullptr);
|
|
|
|
EXPECT_TRUE(deno_execute(d, "a.js", "SnapshotBug()"));
|
|
|
|
deno_delete(d);
|
|
|
|
}
|
|
|
|
|
2018-06-22 08:57:49 -04:00
|
|
|
TEST(MockRuntimeTest, ErrorHandling) {
|
|
|
|
static int count = 0;
|
2018-07-06 16:26:34 -04:00
|
|
|
Deno* d = deno_new(nullptr, [](auto deno, auto buf) {
|
2018-06-22 08:57:49 -04:00
|
|
|
count++;
|
2018-07-08 21:35:34 -04:00
|
|
|
EXPECT_EQ(static_cast<size_t>(1), buf.data_len);
|
|
|
|
EXPECT_EQ(buf.data_ptr[0], 42);
|
2018-06-22 08:57:49 -04:00
|
|
|
});
|
|
|
|
EXPECT_FALSE(deno_execute(d, "a.js", "ErrorHandling()"));
|
|
|
|
EXPECT_EQ(count, 1);
|
|
|
|
deno_delete(d);
|
|
|
|
}
|