1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

crate::ix!();

//-------------------------------------------[.cpp/bitcoin/src/qt/test/rpcnestedtests.h]

#[Q_OBJECT]
pub struct RPCNestedTests {
    base: QObject,
    node: Rc<RefCell<dyn NodeInterface>>,
}

impl RPCNestedTests {
    
    pub fn new(node: Rc<RefCell<dyn NodeInterface>>) -> Self {
    
        todo!();
        /*
        : node(node),

        
        */
    }

    #[Q_SLOT]
    pub fn rpc_nested_tests(&mut self)  {
        
        todo!();
        /*
            // do some test setup
        // could be moved to a more generic place when we add more tests on QT level
        for (const auto& c : vRPCCommands) {
            tableRPC.appendCommand(c.name, &c);
        }

        TestingSetup test;
        m_node.setContext(&test.m_node);

        if (RPCIsInWarmup(nullptr)) SetRPCWarmupFinished();

        std::string result;
        std::string result2;
        std::string filtered;
        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo()[chain]", &filtered); //simple result filtering with path
        QVERIFY(result=="main");
        QVERIFY(filtered == "getblockchaininfo()[chain]");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblock(getbestblockhash())"); //simple 2 level nesting
        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblock(getblock(getbestblockhash())[hash], true)");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblock( getblock( getblock(getbestblockhash())[hash] )[hash], true)"); //4 level nesting with whitespace, filtering path and boolean parameter

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo");
        QVERIFY(result.substr(0,1) == "{");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo()");
        QVERIFY(result.substr(0,1) == "{");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo "); //whitespace at the end will be tolerated
        QVERIFY(result.substr(0,1) == "{");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo()[\"chain\"]"); //Quote path identifier are allowed, but look after a child containing the quotes in the key
        QVERIFY(result == "null");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "createrawtransaction [] {} 0"); //parameter not in brackets are allowed
        RPCConsole::RPCExecuteCommandLine(m_node, result2, "createrawtransaction([],{},0)"); //parameter in brackets are allowed
        QVERIFY(result == result2);
        RPCConsole::RPCExecuteCommandLine(m_node, result2, "createrawtransaction( [],  {} , 0   )"); //whitespace between parameters is allowed
        QVERIFY(result == result2);

        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblock(getbestblockhash())[tx][0]", &filtered);
        QVERIFY(result == "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b");
        QVERIFY(filtered == "getblock(getbestblockhash())[tx][0]");

        RPCConsole::RPCParseCommandLine(nullptr, result, "importprivkey", false, &filtered);
        QVERIFY(filtered == "importprivkey(…)");
        RPCConsole::RPCParseCommandLine(nullptr, result, "signmessagewithprivkey abc", false, &filtered);
        QVERIFY(filtered == "signmessagewithprivkey(…)");
        RPCConsole::RPCParseCommandLine(nullptr, result, "signmessagewithprivkey abc,def", false, &filtered);
        QVERIFY(filtered == "signmessagewithprivkey(…)");
        RPCConsole::RPCParseCommandLine(nullptr, result, "signrawtransactionwithkey(abc)", false, &filtered);
        QVERIFY(filtered == "signrawtransactionwithkey(…)");
        RPCConsole::RPCParseCommandLine(nullptr, result, "walletpassphrase(help())", false, &filtered);
        QVERIFY(filtered == "walletpassphrase(…)");
        RPCConsole::RPCParseCommandLine(nullptr, result, "walletpassphrasechange(help(walletpassphrasechange(abc)))", false, &filtered);
        QVERIFY(filtered == "walletpassphrasechange(…)");
        RPCConsole::RPCParseCommandLine(nullptr, result, "help(encryptwallet(abc, def))", false, &filtered);
        QVERIFY(filtered == "help(encryptwallet(…))");
        RPCConsole::RPCParseCommandLine(nullptr, result, "help(importprivkey())", false, &filtered);
        QVERIFY(filtered == "help(importprivkey(…))");
        RPCConsole::RPCParseCommandLine(nullptr, result, "help(importprivkey(help()))", false, &filtered);
        QVERIFY(filtered == "help(importprivkey(…))");
        RPCConsole::RPCParseCommandLine(nullptr, result, "help(importprivkey(abc), walletpassphrase(def))", false, &filtered);
        QVERIFY(filtered == "help(importprivkey(…), walletpassphrase(…))");

        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest");
        QVERIFY(result == "[]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest ''");
        QVERIFY(result == "[\"\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest \"\"");
        QVERIFY(result == "[\"\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest '' abc");
        QVERIFY(result == "[\"\",\"abc\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest abc '' abc");
        QVERIFY(result == "[\"abc\",\"\",\"abc\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest abc  abc");
        QVERIFY(result == "[\"abc\",\"abc\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest abc\t\tabc");
        QVERIFY(result == "[\"abc\",\"abc\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest(abc )");
        QVERIFY(result == "[\"abc\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest( abc )");
        QVERIFY(result == "[\"abc\"]");
        RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest(   abc   ,   cba )");
        QVERIFY(result == "[\"abc\",\"cba\"]");

        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo() .\n"), std::runtime_error); //invalid syntax
        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo() getblockchaininfo()"), std::runtime_error); //invalid syntax
        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo("); //tolerate non closing brackets if we have no arguments
        RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo()()()"); //tolerate non command brackets
        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "getblockchaininfo(True)"), UniValue); //invalid argument
        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "a(getblockchaininfo(True))"), UniValue); //method not found
        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest abc,,abc"), std::runtime_error); //don't tolerate empty arguments when using ,
        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest(abc,,abc)"), std::runtime_error); //don't tolerate empty arguments when using ,
        QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(m_node, result, "rpcNestedTest(abc,,)"), std::runtime_error); //don't tolerate empty arguments when using ,
        */
    }
}

//-------------------------------------------[.cpp/bitcoin/src/qt/test/rpcnestedtests.cpp]

pub fn rpc_nested_test_rpc() -> RPCHelpMan {
    
    todo!();
        /*
            return RPCHelpMan{
            "rpcNestedTest",
            "echo the passed string(s)",
            {
                {"arg1", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""},
                {"arg2", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""},
                {"arg3", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""},
            },
            RPCResult{RPCResult::Type::ANY, "", ""},
            RPCExamples{""},
            [&](const RPCHelpMan& self, const JSONRPCRequest& request) -> UniValue {
                return request.params.write(0, 0);
            },
        };
        */
}

lazy_static!{
    /*
    static const CRPCCommand vRPCCommands[] = {
        {"rpcNestedTest", &rpcNestedTest_rpc},
    };
    */
}