status-im
/
react-native
mirror of https://github.com/status-im/react-native.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move some really old tests to the cxx bridge 

Reviewed By: mhorowitz

Differential Revision: D3507905

fbshipit-source-id: cbe55495a991bf6eef961319ba8b219e660dce05
This commit is contained in:
Chris Hopman 2016-07-25 12:19:46 -07:00 committed by Facebook Github Bot 0
parent c658cc545f
commit d67258eb91
13 changed files with 429 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ReactAndroid/src/main/jni/react/test/.gitignore vendored
View File

@ -1,2 +0,0 @@
libs
obj

26
ReactAndroid/src/main/jni/react/test/Android.mk
View File

@ -1,26 +0,0 @@
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
jscexecutor.cpp \
jsclogging.cpp \
value.cpp \
methodcall.cpp \
LOCAL_SHARED_LIBRARIES := \
libfb \
libreactnative \
libjsc
LOCAL_STATIC_LIBRARIES := \
libgoogletest
LOCAL_MODULE := reactnative_test
LOCAL_CFLAGS += $(BUCK_DEP_CFLAGS)
LOCAL_LDFLAGS += $(BUCK_DEP_LDFLAGS)
include $(BUILD_EXECUTABLE)
$(call import-module,react)

1
ReactAndroid/src/main/jni/react/test/jni/Android.mk
View File

@ -1 +0,0 @@
include ../Android.mk

6
ReactAndroid/src/main/jni/react/test/jni/Application.mk
View File

@ -1,6 +0,0 @@
ROOT := $(abspath $(call my-dir))/../../..
include $(ROOT)/Application.mk
APP_ABI := armeabi-v7a x86
APP_STL := gnustl_shared
APP_BUILD_SCRIPT := Android.mk

219
ReactAndroid/src/main/jni/react/test/jscexecutor.cpp
View File

@ -1,219 +0,0 @@
// Copyright 2004-present Facebook. All Rights Reserved.
#include <gtest/gtest.h>
#include <react/JSCExecutor.h>
using namespace facebook;
using namespace facebook::react;
TEST(JSCExecutor, Initialize) {
JSCExecutor executor;
}
TEST(JSCExecutor, Two) {
JSCExecutor exec1;
JSCExecutor exec2;
}
static std::vector<MethodCall> executeForMethodCalls(
JSCExecutor& e,
int moduleId,
int methodId,
std::vector<MethodArgument> args = std::vector<MethodArgument>()) {
return parseMethodCalls(e.callFunction(moduleId, methodId, std::move(args)));
}
TEST(JSCExecutor, CallFunction) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" return [[module + 1], [method + 1], [args]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
std::vector<MethodArgument> args;
args.emplace_back(true);
args.emplace_back(0.4);
args.emplace_back("hello, world");
args.emplace_back(4.0);
auto returnedCalls = executeForMethodCalls(e, 10, 9, args);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
EXPECT_EQ(11, returnedCall.moduleId);
EXPECT_EQ(10, returnedCall.methodId);
ASSERT_EQ(4, returnedCall.arguments.size());
EXPECT_EQ(args[0], returnedCall.arguments[0]);
EXPECT_EQ(args[1], returnedCall.arguments[1]);
EXPECT_EQ(args[2], returnedCall.arguments[2]);
EXPECT_EQ(MethodArgument(4.0), returnedCall.arguments[3]);
}
TEST(JSCExecutor, CallFunctionWithMap) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = args[0].foo + args[0].bar + args[0].baz;"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
std::vector<MethodArgument> args;
std::map<std::string, MethodArgument> map {
{ "foo", MethodArgument("hello") },
{ "bar", MethodArgument(4.0) },
{ "baz", MethodArgument(true) },
};
args.emplace_back(std::move(map));
auto returnedCalls = executeForMethodCalls(e, 10, 9, args);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::String, returnedCall.arguments[0].type);
EXPECT_EQ("hello4true", returnedCall.arguments[0].string);
}
TEST(JSCExecutor, CallFunctionReturningMap) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = { foo: 4, bar: true };"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Map, returnedCall.arguments[0].type);
auto& returnedMap = returnedCall.arguments[0].map;
auto fooIter = returnedMap.find("foo");
ASSERT_NE(returnedMap.end(), fooIter);
EXPECT_EQ(MethodArgument(4.0), fooIter->second);
auto barIter = returnedMap.find("bar");
ASSERT_NE(returnedMap.end(), barIter);
EXPECT_EQ(MethodArgument(true), barIter->second);
}
TEST(JSCExecutor, CallFunctionWithArray) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = args[0][0]+ args[0][1] + args[0][2] + args[0].length;"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
std::vector<MethodArgument> args;
std::vector<MethodArgument> array {
MethodArgument("hello"),
MethodArgument(4.0),
MethodArgument(true),
};
args.emplace_back(std::move(array));
auto returnedCalls = executeForMethodCalls(e, 10, 9, args);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::String, returnedCall.arguments[0].type);
EXPECT_EQ("hello4true3", returnedCall.arguments[0].string);
}
TEST(JSCExecutor, CallFunctionReturningNumberArray) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = [3, 1, 4];"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Array, returnedCall.arguments[0].type);
auto& array = returnedCall.arguments[0].array;
EXPECT_EQ(3, array.size());
EXPECT_EQ(MethodArgument(3.0), array[0]);
EXPECT_EQ(MethodArgument(4.0), array[2]);
}
TEST(JSCExecutor, SetSimpleGlobalVariable) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" return [[module], [method], [[__foo]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
e.setGlobalVariable("__foo", "42");
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Number, returnedCall.arguments[0].type);
ASSERT_EQ(MethodArgument(42.0), returnedCall.arguments[0]);
}
TEST(JSCExecutor, SetObjectGlobalVariable) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" return [[module], [method], [[__foo]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e;
e.loadApplicationScript(jsText, "");
auto jsonObject = ""
"{"
" \"foo\": \"hello\","
" \"bar\": 4,"
" \"baz\": true"
"}"
"";
e.setGlobalVariable("__foo", jsonObject);
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Map, returnedCall.arguments[0].type);
auto& returnedMap = returnedCall.arguments[0].map;
auto fooIter = returnedMap.find("foo");
ASSERT_NE(returnedMap.end(), fooIter);
EXPECT_EQ(MethodArgument("hello"), fooIter->second);
auto barIter = returnedMap.find("bar");
ASSERT_NE(returnedMap.end(), barIter);
EXPECT_EQ(MethodArgument(4.0), barIter->second);
auto bazIter = returnedMap.find("baz");
ASSERT_NE(returnedMap.end(), bazIter);
EXPECT_EQ(MethodArgument(true), bazIter->second);
}
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

115
ReactAndroid/src/main/jni/react/test/methodcall.cpp
View File

@ -1,115 +0,0 @@
// Copyright 2004-present Facebook. All Rights Reserved.
#include <gtest/gtest.h>
#include <react/MethodCall.h>
using namespace facebook;
using namespace facebook::react;
TEST(parseMethodCalls, SingleReturnCallNoArgs) {
auto jsText = "[[7],[3],[[]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(0, returnedCall.arguments.size());
ASSERT_EQ(7, returnedCall.moduleId);
ASSERT_EQ(3, returnedCall.methodId);
}
TEST(parseMethodCalls, InvalidReturnFormat) {
ASSERT_TRUE(parseMethodCalls("{\"foo\":1}").empty());
ASSERT_TRUE(parseMethodCalls("[{\"foo\":1}]").empty());
ASSERT_TRUE(parseMethodCalls("[1,4,{\"foo\":2}]").empty());
ASSERT_TRUE(parseMethodCalls("[[1],[4],{\"foo\":2}]").empty());
ASSERT_TRUE(parseMethodCalls("[[1],[4],[]]").empty());
}
TEST(parseMethodCalls, NumberReturn) {
auto jsText = "[[0],[0],[[\"foobar\"]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::String, returnedCall.arguments[0].type);
ASSERT_EQ("foobar", returnedCall.arguments[0].string);
}
TEST(parseMethodCalls, StringReturn) {
auto jsText = "[[0],[0],[[42.16]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Number, returnedCall.arguments[0].type);
ASSERT_EQ(42.16, returnedCall.arguments[0].number);
}
TEST(parseMethodCalls, BooleanReturn) {
auto jsText = "[[0],[0],[[false]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Boolean, returnedCall.arguments[0].type);
ASSERT_FALSE(returnedCall.arguments[0].boolean);
}
TEST(parseMethodCalls, NullReturn) {
auto jsText = "[[0],[0],[[null]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Null, returnedCall.arguments[0].type);
}
TEST(parseMethodCalls, MapReturn) {
auto jsText = "[[0],[0],[[{\"foo\": \"hello\", \"bar\": 4.0, \"baz\": true}]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Map, returnedCall.arguments[0].type);
auto& returnedMap = returnedCall.arguments[0].map;
auto fooIter = returnedMap.find("foo");
ASSERT_NE(returnedMap.end(), fooIter);
EXPECT_EQ(MethodArgument("hello"), fooIter->second);
auto barIter = returnedMap.find("bar");
ASSERT_NE(returnedMap.end(), barIter);
EXPECT_EQ(MethodArgument(4.0), barIter->second);
auto bazIter = returnedMap.find("baz");
ASSERT_NE(returnedMap.end(), bazIter);
EXPECT_EQ(MethodArgument(true), bazIter->second);
}
TEST(parseMethodCalls, ArrayReturn) {
auto jsText = "[[0],[0],[[[\"foo\", 42.0, false]]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::Array, returnedCall.arguments[0].type);
auto& returnedArray = returnedCall.arguments[0].array;
ASSERT_EQ(3, returnedArray.size());
ASSERT_EQ(MethodArgument("foo"), returnedArray[0]);
ASSERT_EQ(MethodArgument(42.0), returnedArray[1]);
ASSERT_EQ(MethodArgument(false), returnedArray[2]);
}
TEST(parseMethodCalls, ReturnMultipleParams) {
auto jsText = "[[0],[0],[[\"foo\", 14, null, false]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(4, returnedCall.arguments.size());
ASSERT_EQ(MethodArgument::Type::String, returnedCall.arguments[0].type);
ASSERT_EQ(MethodArgument::Type::Number, returnedCall.arguments[1].type);
ASSERT_EQ(MethodArgument::Type::Null, returnedCall.arguments[2].type);
ASSERT_EQ(MethodArgument::Type::Boolean, returnedCall.arguments[3].type);
}
TEST(parseMethodCalls, ParseTwoCalls) {
auto jsText = "[[0,0],[1,1],[[],[]]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(2, returnedCalls.size());
}

19
ReactAndroid/src/main/jni/react/test/run
View File

@ -1,19 +0,0 @@
#!/bin/sh
ABI=`adb shell getprop ro.product.cpu.abi | tr -d '\r'`
OUTPUT_DIR=/data/local/tmp
cd $(dirname $0)
ndk-build -j8
if [[ "$?" != "0" ]]; then
echo "Compile failed"
exit 1
fi
# Copy over files
for f in libs/$ABI/*; do
adb push $f $OUTPUT_DIR;
done
# Execute
adb shell "LD_LIBRARY_PATH=$OUTPUT_DIR $OUTPUT_DIR/reactnative_test $*"

5
ReactCommon/cxxreact/MethodCall.cpp
View File

@ -40,6 +40,11 @@ std::vector<MethodCall> parseMethodCalls(const std::string& json) throw(std::inv
folly::to<std::string>("Did not get valid calls back from JS: ", json.c_str()));
}
if (moduleIds.size() != methodIds.size() || moduleIds.size() != params.size()) {
throw std::invalid_argument(
folly::to<std::string>("Did not get valid calls back from JS: ", json.c_str()));
}
if (jsonData.size() > REQUEST_CALLID) {
if (!jsonData[REQUEST_CALLID].isInt()) {
throw std::invalid_argument(

5
ReactCommon/cxxreact/tests/BUCK
View File

@ -7,11 +7,16 @@ jni_instrumentation_test_lib(
soname = 'libxplat-bridge.so',
srcs = [
'CxxMessageQueueTest.cpp',
'value.cpp',
'methodcall.cpp',
'jsclogging.cpp',
'jscexecutor.cpp',
],
compiler_flags = [
'-fexceptions',
],
deps = [
'//native/third-party/android-ndk:android',
'//xplat/third-party/gmock:gtest',
react_native_xplat_target('cxxreact:bridge'),
],

270
ReactCommon/cxxreact/tests/jscexecutor.cpp Normal file
View File

@ -0,0 +1,270 @@
// Copyright 2004-present Facebook. All Rights Reserved.
#include <gtest/gtest.h>
#include <cxxreact/JSCExecutor.h>
#include <cxxreact/MessageQueueThread.h>
#include <cxxreact/MethodCall.h>
using namespace facebook;
using namespace facebook::react;
// TODO(12340362): Fix these tests. And add checks for sizes.
/*
namespace {
std::string capturedMethodCalls;
struct NullDelegate : ExecutorDelegate {
virtual void registerExecutor(std::unique_ptr<JSExecutor> executor,
std::shared_ptr<MessageQueueThread> queue) {
std::terminate();
}
virtual std::unique_ptr<JSExecutor> unregisterExecutor(JSExecutor& executor) {
std::terminate();
}
virtual std::vector<std::string> moduleNames() {
return std::vector<std::string>{};
}
virtual folly::dynamic getModuleConfig(const std::string& name) {
std::terminate();
}
virtual void callNativeModules(
JSExecutor& executor, std::string callJSON, bool isEndOfBatch) {
// TODO: capture calljson
std::terminate();
}
virtual MethodCallResult callSerializableNativeHook(
JSExecutor& executor, unsigned int moduleId, unsigned int methodId, folly::dynamic&& args) {
std::terminate();
}
};
struct FakeMessageQueue : MessageQueueThread {
virtual void runOnQueue(std::function<void()>&& runnable) {
// This is wrong, but oh well.
runnable();
}
virtual void runOnQueueSync(std::function<void()>&& runnable) {
runnable();
}
virtual void quitSynchronous() {
std::terminate();
}
};
std::vector<MethodCall> executeForMethodCalls(
JSCExecutor& e,
int moduleId,
int methodId,
folly::dynamic args = folly::dynamic::array()) {
e.callFunction(folly::to<std::string>(moduleId), folly::to<std::string>(methodId), std::move(args));
return parseMethodCalls(capturedMethodCalls);
}
void loadApplicationScript(JSCExecutor& e, std::string jsText) {
e.loadApplicationScript(std::unique_ptr<JSBigString>(new JSBigStdString(jsText)), "");
}
void setGlobalVariable(JSCExecutor& e, std::string name, std::string jsonObject) {
e.setGlobalVariable(name, std::unique_ptr<JSBigString>(new JSBigStdString(jsonObject)));
}
}
TEST(JSCExecutor, Initialize) {
JSCExecutor executor(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
}
TEST(JSCExecutor, Two) {
JSCExecutor exec1(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
JSCExecutor exec2(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
}
TEST(JSCExecutor, CallFunction) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" return [[module + 1], [method + 1], [args]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
folly::dynamic args = folly::dynamic::array();
args.push_back(true);
args.push_back(0.4);
args.push_back("hello, world");
args.push_back(4.0);
auto returnedCalls = executeForMethodCalls(e, 10, 9, args);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
EXPECT_EQ(11, returnedCall.moduleId);
EXPECT_EQ(10, returnedCall.methodId);
ASSERT_EQ(4, returnedCall.arguments.size());
EXPECT_EQ(args[0], returnedCall.arguments[0]);
EXPECT_EQ(args[1], returnedCall.arguments[1]);
EXPECT_EQ(args[2], returnedCall.arguments[2]);
EXPECT_EQ(folly::dynamic(4.0), returnedCall.arguments[3]);
}
TEST(JSCExecutor, CallFunctionWithMap) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = args[0].foo + args[0].bar + args[0].baz;"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
folly::dynamic args = folly::dynamic::array();
folly::dynamic map = folly::dynamic::object
("foo", folly::dynamic("hello"))
("bar", folly::dynamic(4.0))
("baz", folly::dynamic(true))
;
args.push_back(std::move(map));
auto returnedCalls = executeForMethodCalls(e, 10, 9, args);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
EXPECT_EQ("hello4true", returnedCall.arguments[0].getString());
}
TEST(JSCExecutor, CallFunctionReturningMap) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = { foo: 4, bar: true };"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::OBJECT, returnedCall.arguments[0].type());
auto& returnedMap = returnedCall.arguments[0];
auto foo = returnedMap.at("foo");
EXPECT_EQ(folly::dynamic(4.0), foo);
auto bar = returnedMap.at("bar");
EXPECT_EQ(folly::dynamic(true), bar);
}
TEST(JSCExecutor, CallFunctionWithArray) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = args[0][0]+ args[0][1] + args[0][2] + args[0].length;"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
std::vector<folly::dynamic> args;
std::vector<folly::dynamic> array {
folly::dynamic("hello"),
folly::dynamic(4.0),
folly::dynamic(true),
};
args.push_back(std::move(array));
auto returnedCalls = executeForMethodCalls(e, 10, 9, args);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
EXPECT_EQ("hello4true3", returnedCall.arguments[0].getString());
}
TEST(JSCExecutor, CallFunctionReturningNumberArray) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" var s = [3, 1, 4];"
" return [[module], [method], [[s]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::ARRAY, returnedCall.arguments[0].type());
auto& array = returnedCall.arguments[0];
EXPECT_EQ(3, array.size());
EXPECT_EQ(folly::dynamic(3.0), array[0]);
EXPECT_EQ(folly::dynamic(4.0), array[2]);
}
TEST(JSCExecutor, SetSimpleGlobalVariable) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" return [[module], [method], [[__foo]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
setGlobalVariable(e, "__foo", "42");
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(42.0, returnedCall.arguments[0].getDouble());
}
TEST(JSCExecutor, SetObjectGlobalVariable) {
auto jsText = ""
"var Bridge = {"
" callFunctionReturnFlushedQueue: function (module, method, args) {"
" return [[module], [method], [[__foo]]];"
" },"
"};"
"function require() { return Bridge; }"
"";
JSCExecutor e(std::make_shared<NullDelegate>(), std::make_shared<FakeMessageQueue>(), "", folly::dynamic::object);
loadApplicationScript(e, jsText);
auto jsonObject = ""
"{"
" \"foo\": \"hello\","
" \"bar\": 4,"
" \"baz\": true"
"}"
"";
setGlobalVariable(e, "__foo", jsonObject);
auto returnedCalls = executeForMethodCalls(e, 10, 9);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::OBJECT, returnedCall.arguments[0].type());
auto& returnedMap = returnedCall.arguments[0];
auto foo = returnedMap.at("foo");
EXPECT_EQ(folly::dynamic("hello"), foo);
auto bar = returnedMap.at("bar");
EXPECT_EQ(folly::dynamic(4.0), bar);
auto baz = returnedMap.at("baz");
EXPECT_EQ(folly::dynamic(true), baz);
}
*/

6
ReactAndroid/src/main/jni/react/test/jsclogging.cpp → ReactCommon/cxxreact/tests/jsclogging.cpp
View File

@ -1,13 +1,12 @@
// Copyright 2004-present Facebook. All Rights Reserved.
#include <gtest/gtest.h>
#include <fb/log.h>
#include <react/JSCExecutor.h>
#include <cxxreact/JSCExecutor.h>
using namespace facebook;
using namespace facebook::react;
/*
static const char* expectedLogMessageSubstring = NULL;
static bool hasSeenExpectedLogMessage = false;
@ -42,3 +41,4 @@ TEST_F(JSCLoggingTest, LogException) {
ASSERT_TRUE(hasSeenExpectedLogMessage);
}
*/

137
ReactCommon/cxxreact/tests/methodcall.cpp Normal file
View File

@ -0,0 +1,137 @@
// Copyright 2004-present Facebook. All Rights Reserved.
#include <gtest/gtest.h>
#include <cxxreact/MethodCall.h>
using namespace facebook;
using namespace facebook::react;
TEST(parseMethodCalls, SingleReturnCallNoArgs) {
auto jsText = "[[7],[3],[\"[]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(0, returnedCall.arguments.size());
ASSERT_EQ(7, returnedCall.moduleId);
ASSERT_EQ(3, returnedCall.methodId);
}
TEST(parseMethodCalls, InvalidReturnFormat) {
try {
parseMethodCalls("{\"foo\":1}");
ADD_FAILURE();
} catch (const std::invalid_argument&) {
// ignored
}
try {
parseMethodCalls("[{\"foo\":1}]");
ADD_FAILURE();
} catch (const std::invalid_argument&) {
// ignored
}
try {
parseMethodCalls("[1,4,{\"foo\":2}]");
ADD_FAILURE();
} catch (const std::invalid_argument&) {
// ignored
}
try {
parseMethodCalls("[[1],[4],{\"foo\":2}]");
ADD_FAILURE();
} catch (const std::invalid_argument&) {
// ignored
}
try {
parseMethodCalls("[[1],[4],[]]");
ADD_FAILURE();
} catch (const std::invalid_argument&) {
// ignored
}
}
TEST(parseMethodCalls, NumberReturn) {
auto jsText = "[[0],[0],[\"[\\\"foobar\\\"]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::STRING, returnedCall.arguments[0].type());
ASSERT_EQ("foobar", returnedCall.arguments[0].asString());
}
TEST(parseMethodCalls, StringReturn) {
auto jsText = "[[0],[0],[\"[42.16]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::DOUBLE, returnedCall.arguments[0].type());
ASSERT_EQ(42.16, returnedCall.arguments[0].asDouble());
}
TEST(parseMethodCalls, BooleanReturn) {
auto jsText = "[[0],[0],[\"[false]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::BOOL, returnedCall.arguments[0].type());
ASSERT_FALSE(returnedCall.arguments[0].asBool());
}
TEST(parseMethodCalls, NullReturn) {
auto jsText = "[[0],[0],[\"[null]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::NULLT, returnedCall.arguments[0].type());
}
TEST(parseMethodCalls, MapReturn) {
auto jsText = "[[0],[0],[\"[{\\\"foo\\\": \\\"hello\\\", \\\"bar\\\": 4.0, \\\"baz\\\": true}]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::OBJECT, returnedCall.arguments[0].type());
auto& returnedMap = returnedCall.arguments[0];
auto foo = returnedMap.at("foo");
EXPECT_EQ(folly::dynamic("hello"), foo);
auto bar = returnedMap.at("bar");
EXPECT_EQ(folly::dynamic(4.0), bar);
auto baz = returnedMap.at("baz");
EXPECT_EQ(folly::dynamic(true), baz);
}
TEST(parseMethodCalls, ArrayReturn) {
auto jsText = "[[0],[0],[\"[[\\\"foo\\\", 42.0, false]]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(1, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::ARRAY, returnedCall.arguments[0].type());
auto& returnedArray = returnedCall.arguments[0];
ASSERT_EQ(3, returnedArray.size());
ASSERT_EQ(folly::dynamic("foo"), returnedArray[0]);
ASSERT_EQ(folly::dynamic(42.0), returnedArray[1]);
ASSERT_EQ(folly::dynamic(false), returnedArray[2]);
}
TEST(parseMethodCalls, ReturnMultipleParams) {
auto jsText = "[[0],[0],[\"[\\\"foo\\\", 14, null, false]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(1, returnedCalls.size());
auto returnedCall = returnedCalls[0];
ASSERT_EQ(4, returnedCall.arguments.size());
ASSERT_EQ(folly::dynamic::STRING, returnedCall.arguments[0].type());
ASSERT_EQ(folly::dynamic::INT64, returnedCall.arguments[1].type());
ASSERT_EQ(folly::dynamic::NULLT, returnedCall.arguments[2].type());
ASSERT_EQ(folly::dynamic::BOOL, returnedCall.arguments[3].type());
}
TEST(parseMethodCalls, ParseTwoCalls) {
auto jsText = "[[0,0],[1,1],[\"[]\",\"[]\"]]";
auto returnedCalls = parseMethodCalls(jsText);
ASSERT_EQ(2, returnedCalls.size());
}

16
ReactAndroid/src/main/jni/react/test/value.cpp → ReactCommon/cxxreact/tests/value.cpp
View File

@ -2,11 +2,13 @@
#include <gtest/gtest.h>
#include <folly/json.h>
#include <react/Value.h>
#include <cxxreact/Value.h>
using namespace facebook;
using namespace facebook::react;
// TODO(cjhopman): Fix these tests.
/*
TEST(Value, Undefined) {
JSContextRef ctx = JSGlobalContextCreateInGroup(nullptr, nullptr);
Value v(ctx, JSValueMakeUndefined(ctx));
@ -26,13 +28,13 @@ TEST(Value, ToJSONString) {
String s("{\"a\": 4}");
Value v(Value::fromJSON(ctx, s));
folly::dynamic dyn = folly::parseJson(v.toJSONString());
ASSERT_NE(nullptr, json);
EXPECT_TRUE(json.isObject());
auto val = json.at("a");
ASSERT_NE(nullptr, dyn);
EXPECT_TRUE(dyn.isObject());
auto val = dyn.at("a");
ASSERT_NE(nullptr, val);
ASSERT_TRUE(val.isInt());
EXPECT_EQ(4, val->getInt());
EXPECT_EQ(4.0f, val->asDouble());
EXPECT_EQ(4, val.getInt());
EXPECT_EQ(4.0f, val.asDouble());
}
*/