Inside Bitcoin

501    BOOST_CHECK_EQUAL(result2[4], 9);
502
503    // Same test as above, but one of the percentile-overlapping pairs is split in 2.
504    total_weight = 100;
505    CAmount result3[NUM_GETBLOCKSTATS_PERCENTILES] = { 0 };
506    feerates.clear();
507
508    feerates.emplace_back(1, 9);
509    feerates.emplace_back(2 , 11); // 10th percentile
510    feerates.emplace_back(2 , 5); // 25th percentile
511    feerates.emplace_back(4 ,50); //50th + 75th percentile
512    feerates.emplace_back(5 ,10);
513    feerates.emplace_back(9 ,15); // 90th percentile
514
515    CalculatePercentilesByWeight(result3, feerates, total_weight);
516
517    BOOST_CHECK_EQUAL(result3[0], 2);
518    BOOST_CHECK_EQUAL(result3[1], 2);
519    BOOST_CHECK_EQUAL(result3[2], 4);
520    BOOST_CHECK_EQUAL(result3[3], 4);
521    BOOST_CHECK_EQUAL(result3[4], 9);
522
523    // Test with one transaction spanning all percentiles.
524    total_weight = 104;
525    CAmount result4[NUM_GETBLOCKSTATS_PERCENTILES] = { 0 };
526    feerates.clear();
527
528    feerates.emplace_back(1, 100);
529    feerates.emplace_back(2, 1);
530    feerates.emplace_back(3, 1);
531    feerates.emplace_back(3, 1);
532    feerates.emplace_back(999999, 1);
533
534    CalculatePercentilesByWeight(result4, feerates, total_weight);
535
536    for (int64_t i = 0; i < NUM_GETBLOCKSTATS_PERCENTILES; i++) {
537        BOOST_CHECK_EQUAL(result4[i], 1);
538    }
539}
540
541// Make sure errors are triggered appropriately if parameters have the same names.
542BOOST_AUTO_TEST_CASE(check_dup_param_names)
543{
544    enum ParamType { POSITIONAL, NAMED, NAMED_ONLY };
545    auto make_rpc = [](std::vector<std::tuple<std::string, ParamType>> param_names) {
546        std::vector<RPCArg> params;
547        std::vector<RPCArg> options;
548        auto push_options = [&] { if (!options.empty()) params.emplace_back(strprintf("options%i", params.size()), RPCArg::Type::OBJ_NAMED_PARAMS, RPCArg::Optional::OMITTED, "", std::move(options)); };
549        for (auto& [param_name, param_type] : param_names) {
550            if (param_type == POSITIONAL) {
551                push_options();
552                params.emplace_back(std::move(param_name), RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "description");
553            } else {
554                options.emplace_back(std::move(param_name), RPCArg::Type::NUM, RPCArg::Optional::OMITTED, "description", RPCArgOptions{.also_positional = param_type == NAMED});
555            }
556        }
557        push_options();
558        return RPCMethod{"method_name", "description", params, RPCResults{}, RPCExamples{""}};
559    };
560
561    // No errors if parameter names are unique.
562    make_rpc({{"p1", POSITIONAL}, {"p2", POSITIONAL}});
563    make_rpc({{"p1", POSITIONAL}, {"p2", NAMED}});
564    make_rpc({{"p1", POSITIONAL}, {"p2", NAMED_ONLY}});
565    make_rpc({{"p1", NAMED}, {"p2", POSITIONAL}});
566    make_rpc({{"p1", NAMED}, {"p2", NAMED}});
567    make_rpc({{"p1", NAMED}, {"p2", NAMED_ONLY}});
568    make_rpc({{"p1", NAMED_ONLY}, {"p2", POSITIONAL}});
569    make_rpc({{"p1", NAMED_ONLY}, {"p2", NAMED}});
570    make_rpc({{"p1", NAMED_ONLY}, {"p2", NAMED_ONLY}});
571
572    {
573        test_only_CheckFailuresAreExceptionsNotAborts mock_checks{};
574        // Error if parameter names are duplicates, unless one parameter is
575        // positional and the other is named and .also_positional is true.
576        BOOST_CHECK_THROW(make_rpc({{"p1", POSITIONAL}, {"p1", POSITIONAL}}), NonFatalCheckError);
577        make_rpc({{"p1", POSITIONAL}, {"p1", NAMED}});
578        BOOST_CHECK_THROW(make_rpc({{"p1", POSITIONAL}, {"p1", NAMED_ONLY}}), NonFatalCheckError);
579        make_rpc({{"p1", NAMED}, {"p1", POSITIONAL}});
580        BOOST_CHECK_THROW(make_rpc({{"p1", NAMED}, {"p1", NAMED}}), NonFatalCheckError);
581        BOOST_CHECK_THROW(make_rpc({{"p1", NAMED}, {"p1", NAMED_ONLY}}), NonFatalCheckError);
582        BOOST_CHECK_THROW(make_rpc({{"p1", NAMED_ONLY}, {"p1", POSITIONAL}}), NonFatalCheckError);
583        BOOST_CHECK_THROW(make_rpc({{"p1", NAMED_ONLY}, {"p1", NAMED}}), NonFatalCheckError);
584        BOOST_CHECK_THROW(make_rpc({{"p1", NAMED_ONLY}, {"p1", NAMED_ONLY}}), NonFatalCheckError);
585
586        // Make sure duplicate aliases are detected too.
587        BOOST_CHECK_THROW(make_rpc({{"p1", POSITIONAL}, {"p2|p1", NAMED_ONLY}}), NonFatalCheckError);
588    }
589}
590
591BOOST_AUTO_TEST_CASE(help_example)
592{
593    // test different argument types
594    const RPCArgList& args = {{"foo", "bar"}, {"b", true}, {"n", 1}};
595    BOOST_CHECK_EQUAL(HelpExampleCliNamed("test", args), "> bitcoin-cli -named test foo=bar b=true n=1\n");
596    BOOST_CHECK_EQUAL(HelpExampleRpcNamed("test", args), "> curl --user myusername --data-binary '{\"jsonrpc\": \"2.0\", \"id\": \"curltest\", \"method\": \"test\", \"params\": {\"foo\":\"bar\",\"b\":true,\"n\":1}}' -H 'content-type: application/json' http://127.0.0.1:8332/\n");
597
598    // test shell escape
599    BOOST_CHECK_EQUAL(HelpExampleCliNamed("test", {{"foo", "b'ar"}}), "> bitcoin-cli -named test foo='b'''ar'\n");
600    BOOST_CHECK_EQUAL(HelpExampleCliNamed("test", {{"foo", "b\"ar"}}), "> bitcoin-cli -named test foo='b\"ar'\n");
601    BOOST_CHECK_EQUAL(HelpExampleCliNamed("test", {{"foo", "b ar"}}), "> bitcoin-cli -named test foo='b ar'\n");
602
603    // test object params
604    UniValue obj_value(UniValue::VOBJ);
605    obj_value.pushKV("foo", "bar");
606    obj_value.pushKV("b", false);
607    obj_value.pushKV("n", 1);
608    BOOST_CHECK_EQUAL(HelpExampleCliNamed("test", {{"name", obj_value}}), "> bitcoin-cli -named test name='{\"foo\":\"bar\",\"b\":false,\"n\":1}'\n");
609    BOOST_CHECK_EQUAL(HelpExampleRpcNamed("test", {{"name", obj_value}}), "> curl --user myusername --data-binary '{\"jsonrpc\": \"2.0\", \"id\": \"curltest\", \"method\": \"test\", \"params\": {\"name\":{\"foo\":\"bar\",\"b\":false,\"n\":1}}}' -H 'content-type: application/json' http://127.0.0.1:8332/\n");
610
611    // test array params
612    UniValue arr_value(UniValue::VARR);
613    arr_value.push_back("bar");
614    arr_value.push_back(false);
615    arr_value.push_back(1);
616    BOOST_CHECK_EQUAL(HelpExampleCliNamed("test", {{"name", arr_value}}), "> bitcoin-cli -named test name='[\"bar\",false,1]'\n");
617    BOOST_CHECK_EQUAL(HelpExampleRpcNamed("test", {{"name", arr_value}}), "> curl --user myusername --data-binary '{\"jsonrpc\": \"2.0\", \"id\": \"curltest\", \"method\": \"test\", \"params\": {\"name\":[\"bar\",false,1]}}' -H 'content-type: application/json' http://127.0.0.1:8332/\n");
618
619    // test types don't matter for shell
620    BOOST_CHECK_EQUAL(HelpExampleCliNamed("foo", {{"arg", true}}), HelpExampleCliNamed("foo", {{"arg", "true"}}));
621
622    // test types matter for Rpc
623    BOOST_CHECK_NE(HelpExampleRpcNamed("foo", {{"arg", true}}), HelpExampleRpcNamed("foo", {{"arg", "true"}}));
624}
625
626static void CheckRpc(const std::vector<RPCArg>& params, const UniValue& args, RPCMethod::RPCMethodImpl test_impl)
627{
628    auto null_result{RPCResult{RPCResult::Type::NONE, "", "None"}};
629    const RPCMethod rpc{"dummy", "dummy description", params, null_result, RPCExamples{""}, test_impl};
630    JSONRPCRequest req;
631    req.params = args;
632
633    rpc.HandleRequest(req);
634}
635
636BOOST_AUTO_TEST_CASE(rpc_arg_helper)
637{
638    constexpr bool DEFAULT_BOOL = true;
639    constexpr auto DEFAULT_STRING = "default";
640    constexpr uint64_t DEFAULT_UINT64_T = 3;
641
642    //! Parameters with which the RPCMethod is instantiated
643    const std::vector<RPCArg> params{
644        // Required arg
645        {"req_int", RPCArg::Type::NUM, RPCArg::Optional::NO, ""},
646        {"req_str", RPCArg::Type::STR, RPCArg::Optional::NO, ""},
647        // Default arg
648        {"def_uint64_t", RPCArg::Type::NUM, RPCArg::Default{DEFAULT_UINT64_T}, ""},
649        {"def_string", RPCArg::Type::STR, RPCArg::Default{DEFAULT_STRING}, ""},
650        {"def_bool", RPCArg::Type::BOOL, RPCArg::Default{DEFAULT_BOOL}, ""},
651        // Optional arg without default
652        {"opt_double", RPCArg::Type::NUM, RPCArg::Optional::OMITTED, ""},
653        {"opt_string", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""}
654    };
655
656    //! Check that `self.Arg` returns the same value as the `request.params` accessors
657    RPCMethod::RPCMethodImpl check_positional = [](const RPCMethod& self, const JSONRPCRequest& request) -> UniValue {
658            BOOST_CHECK_EQUAL(self.Arg<int>("req_int"), request.params[0].getInt<int>());
659            BOOST_CHECK_EQUAL(self.Arg<std::string_view>("req_str"), request.params[1].get_str());
660            BOOST_CHECK_EQUAL(self.Arg<uint64_t>("def_uint64_t"), request.params[2].isNull() ? DEFAULT_UINT64_T : request.params[2].getInt<uint64_t>());
661            BOOST_CHECK_EQUAL(self.Arg<std::string_view>("def_string"), request.params[3].isNull() ? DEFAULT_STRING : request.params[3].get_str());
662            BOOST_CHECK_EQUAL(self.Arg<bool>("def_bool"), request.params[4].isNull() ? DEFAULT_BOOL : request.params[4].get_bool());
663            if (!request.params[5].isNull()) {
664                BOOST_CHECK_EQUAL(self.MaybeArg<double>("opt_double").value(), request.params[5].get_real());
665            } else {
666                BOOST_CHECK(!self.MaybeArg<double>("opt_double"));
667            }
668            if (!request.params[6].isNull()) {
669                BOOST_CHECK_EQUAL(self.MaybeArg<std::string_view>("opt_string"), request.params[6].get_str());
670            } else {
671                BOOST_CHECK(!self.MaybeArg<std::string_view>("opt_string"));
672            }
673            return UniValue{};
674        };
675    CheckRpc(params, UniValue{JSON(R"([5, "hello", null, null, null, null, null])")}, check_positional);
676    CheckRpc(params, UniValue{JSON(R"([5, "hello", 4, "test", true, 1.23, "world"])")}, check_positional);
677}
678
679BOOST_AUTO_TEST_SUITE_END()
680