114 lines
4.3 KiB
C++
114 lines
4.3 KiB
C++
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#include <cxxreact/JsArgumentHelpers.h>
|
|
|
|
#include <folly/dynamic.h>
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <algorithm>
|
|
|
|
using namespace facebook::xplat;
|
|
using dynamic = folly::dynamic;
|
|
|
|
#define EXPECT_JSAE(statement, exstr) \
|
|
do { \
|
|
try { \
|
|
statement; \
|
|
FAIL() << "Expected JsArgumentException(" << (exstr) << ") not thrown"; \
|
|
} catch (const JsArgumentException &ex) { \
|
|
EXPECT_EQ(ex.what(), std::string(exstr)); \
|
|
} \
|
|
} while (0) // let any other exception escape, gtest will deal.
|
|
|
|
TEST(JsArgumentHelpersTest, args) {
|
|
const bool aBool = true;
|
|
const int64_t anInt = 17;
|
|
const double aDouble = 3.14;
|
|
const std::string aString = "word";
|
|
const dynamic anArray = dynamic::array("a", "b", "c");
|
|
const dynamic anObject = dynamic::object("k1", "v1")("k2", "v2");
|
|
const std::string aNumericString = folly::to<std::string>(anInt);
|
|
|
|
folly::dynamic args = dynamic::array(
|
|
aBool, anInt, aDouble, aString, anArray, anObject, aNumericString);
|
|
|
|
EXPECT_EQ(jsArgAsBool(args, 0), aBool);
|
|
EXPECT_EQ(jsArgAsInt(args, 1), anInt);
|
|
EXPECT_EQ(jsArgAsDouble(args, 2), aDouble);
|
|
EXPECT_EQ(jsArgAsString(args, 3), aString);
|
|
EXPECT_EQ(jsArgAsArray(args, 4), anArray);
|
|
EXPECT_EQ(jsArgAsObject(args, 5), anObject);
|
|
|
|
// const args
|
|
const folly::dynamic &cargs = args;
|
|
const folly::dynamic &a4 = jsArgAsArray(cargs, 4);
|
|
EXPECT_EQ(a4, anArray);
|
|
EXPECT_EQ(jsArgAsObject(cargs, 5), anObject);
|
|
|
|
// helpers returning dynamic should return same object without copying
|
|
EXPECT_EQ(&jsArgAsArray(args, 4), &(args[4]));
|
|
EXPECT_EQ(&jsArgAsArray(cargs, 4), &(args[4]));
|
|
|
|
// dynamics returned for mutable args should be mutable. The test is that
|
|
// this compiles.
|
|
jsArgAsArray(args, 4)[2] = "d";
|
|
jsArgAsArray(args, 4)[2] = "c";
|
|
// These fail to compile due to constness.
|
|
// jsArgAsArray(cargs, 4)[2] = "d";
|
|
// jsArgAsArray(cargs, 4)[2] = "c";
|
|
|
|
// ref-qualified member function tests
|
|
EXPECT_EQ(jsArgN(args, 3, &folly::dynamic::getString), aString);
|
|
EXPECT_EQ(jsArg(args[3], &folly::dynamic::getString), aString);
|
|
|
|
// conversions
|
|
EXPECT_EQ(jsArgAsDouble(args, 1), anInt * 1.0);
|
|
EXPECT_EQ(jsArgAsString(args, 1), aNumericString);
|
|
EXPECT_EQ(jsArgAsInt(args, 6), anInt);
|
|
|
|
// Test exception messages.
|
|
|
|
// out_of_range
|
|
EXPECT_JSAE(
|
|
jsArgAsBool(args, 7),
|
|
"JavaScript provided 7 arguments for C++ method which references at least "
|
|
"8 arguments: out of range in dynamic array");
|
|
// Conv range_error (invalid value conversion)
|
|
const std::string exhead = "Could not convert argument 3 to required type: ";
|
|
const std::string extail = ": Invalid leading character: \"word\"";
|
|
try {
|
|
jsArgAsInt(args, 3);
|
|
FAIL() << "Expected JsArgumentException(" << exhead << "..." << extail
|
|
<< ") not thrown";
|
|
} catch (const JsArgumentException &ex) {
|
|
const std::string exwhat = ex.what();
|
|
|
|
EXPECT_GT(exwhat.size(), exhead.size());
|
|
EXPECT_GT(exwhat.size(), extail.size());
|
|
|
|
EXPECT_TRUE(std::equal(exhead.cbegin(), exhead.cend(), exwhat.cbegin()))
|
|
<< "JsArgumentException('" << exwhat << "') does not begin with '"
|
|
<< exhead << "'";
|
|
EXPECT_TRUE(std::equal(extail.crbegin(), extail.crend(), exwhat.crbegin()))
|
|
<< "JsArgumentException('" << exwhat << "') does not end with '"
|
|
<< extail << "'";
|
|
}
|
|
// inconvertible types
|
|
EXPECT_JSAE(
|
|
jsArgAsArray(args, 2),
|
|
"Argument 3 of type double is not required type Array");
|
|
EXPECT_JSAE(
|
|
jsArgAsInt(args, 4),
|
|
"Error converting javascript arg 4 to C++: "
|
|
"TypeError: expected dynamic type `int/double/bool/string', but had type `array'");
|
|
// type predicate failure
|
|
EXPECT_JSAE(
|
|
jsArgAsObject(args, 4),
|
|
"Argument 5 of type array is not required type Object");
|
|
}
|