rippled
RPCCall_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2018 Ripple Labs Inc.
5  Permission to use, copy, modify, and/or distribute this software for any
6  purpose with or without fee is hereby granted, provided that the above
7  copyright notice and this permission notice appear in all copies.
8  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16 //==============================================================================
17 
18 #include <ripple/beast/unit_test.h>
19 #include <ripple/json/json_reader.h>
20 #include <ripple/net/RPCCall.h>
21 #include <ripple/protocol/ErrorCodes.h>
22 #include <ripple/rpc/impl/RPCHelpers.h>
23 #include <test/jtx.h>
24 
25 #include <boost/algorithm/string.hpp>
26 #include <initializer_list>
27 #include <vector>
28 
29 namespace ripple {
30 namespace test {
31 
32 struct RPCCallTestData
33 {
34  char const* const description;
35  int const line;
36  // List of passed arguments.
37  std::vector<char const*> const args;
38 
39  // If it throws, what does it throw?
40  enum Exception { no_exception = 0, bad_cast };
41  Exception const throwsWhat;
42 
43  // Expected JSON response.
44  char const* const exp;
45 
46  RPCCallTestData(
47  char const* description_,
48  int line_,
49  std::initializer_list<char const*> const& args_,
50  Exception throwsWhat_,
51  char const* exp_)
52  : description(description_)
53  , line(line_)
54  , args(args_)
55  , throwsWhat(throwsWhat_)
56  , exp(exp_)
57  {
58  }
59 
60  RPCCallTestData() = delete;
61  RPCCallTestData(RPCCallTestData const&) = delete;
62  RPCCallTestData(RPCCallTestData&&) = delete;
63  RPCCallTestData&
64  operator=(RPCCallTestData const&) = delete;
65  RPCCallTestData&
66  operator=(RPCCallTestData&&) = delete;
67 };
68 
69 static RPCCallTestData const rpcCallTestArray[] = {
70  // account_channels
71  // ------------------------------------------------------------
72  {"account_channels: minimal.",
73  __LINE__,
74  {"account_channels", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
75  RPCCallTestData::no_exception,
76  R"({
77  "method" : "account_channels",
78  "params" : [
79  {
80  "api_version" : %MAX_API_VER%,
81  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
82  }
83  ]
84  })"},
85  {"account_channels: account and ledger hash.",
86  __LINE__,
87  {"account_channels",
88  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
89  "rD5MbavGfiSC5m7mkxy1FANuT7s3HxqpoF"},
90  RPCCallTestData::no_exception,
91  R"({
92  "method" : "account_channels",
93  "params" : [
94  {
95  "api_version" : %MAX_API_VER%,
96  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
97  "destination_account" : "rD5MbavGfiSC5m7mkxy1FANuT7s3HxqpoF"
98  }
99  ]
100  })"},
101  {"account_channels: account and ledger index.",
102  __LINE__,
103  {"account_channels",
104  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
105  "r9emE59aTWb85t64dAebKrxYMBTpzK5yR7"},
106  RPCCallTestData::no_exception,
107  R"({
108  "method" : "account_channels",
109  "params" : [
110  {
111  "api_version" : %MAX_API_VER%,
112  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
113  "destination_account" : "r9emE59aTWb85t64dAebKrxYMBTpzK5yR7"
114  }
115  ]
116  })"},
117  {"account_channels: two accounts.",
118  __LINE__,
119  {"account_channels",
120  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
121  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
122  RPCCallTestData::no_exception,
123  R"({
124  "method" : "account_channels",
125  "params" : [
126  {
127  "api_version" : %MAX_API_VER%,
128  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
129  "destination_account" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
130  }
131  ]
132  })"},
133  {"account_channels: two accounts and ledger hash.",
134  __LINE__,
135  {"account_channels",
136  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
137  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
138  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
139  RPCCallTestData::no_exception,
140  R"({
141  "method" : "account_channels",
142  "params" : [
143  {
144  "api_version" : %MAX_API_VER%,
145  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
146  "destination_account" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
147  "ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
148  }
149  ]
150  })"},
151  {"account_channels: two accounts and ledger index.",
152  __LINE__,
153  {"account_channels",
154  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
155  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
156  "90210"},
157  RPCCallTestData::no_exception,
158  R"({
159  "method" : "account_channels",
160  "params" : [
161  {
162  "api_version" : %MAX_API_VER%,
163  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
164  "destination_account" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
165  "ledger_index" : 90210
166  }
167  ]
168  })"},
169  {"account_channels: too few arguments.",
170  __LINE__,
171  {
172  "account_channels",
173  },
174  RPCCallTestData::no_exception,
175  R"({
176  "method" : "account_channels",
177  "params" : [
178  {
179  "error" : "badSyntax",
180  "error_code" : 1,
181  "error_message" : "Syntax error."
182  }
183  ]
184  })"},
185  {"account_channels: too many arguments.",
186  __LINE__,
187  {"account_channels",
188  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
189  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
190  "current",
191  "extra"},
192  RPCCallTestData::no_exception,
193  R"({
194  "method" : "account_channels",
195  "params" : [
196  {
197  "error" : "badSyntax",
198  "error_code" : 1,
199  "error_message" : "Syntax error."
200  }
201  ]
202  })"},
203  {"account_channels: invalid accountID.",
204  __LINE__,
205  {
206  "account_channels",
207  "", // Note: very few values are detected as bad!
208  },
209  RPCCallTestData::no_exception,
210  R"({
211  "method" : "account_channels",
212  "params" : [
213  {
214  "error" : "actMalformed",
215  "error_code" : 35,
216  "error_message" : "Account malformed."
217  }
218  ]
219  })"},
220 
221  // account_currencies
222  // ----------------------------------------------------------
223  {"account_currencies: minimal 1.",
224  __LINE__,
225  {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
226  RPCCallTestData::no_exception,
227  R"({
228  "method" : "account_currencies",
229  "params" : [
230  {
231  "api_version" : %MAX_API_VER%,
232  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
233  }
234  ]
235  })"},
236  {"account_currencies: minimal 2.",
237  __LINE__,
238  {"account_currencies", "racb4o3DrdYxuCfyVa6vsLb7vgju9RFbBr"},
239  RPCCallTestData::no_exception,
240  R"({
241  "method" : "account_currencies",
242  "params" : [
243  {
244  "api_version" : %MAX_API_VER%,
245  "account" : "racb4o3DrdYxuCfyVa6vsLb7vgju9RFbBr"
246  }
247  ]
248  })"},
249  {"account_currencies: ledger index.",
250  __LINE__,
251  {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "42"},
252  RPCCallTestData::no_exception,
253  R"({
254  "method" : "account_currencies",
255  "params" : [
256  {
257  "api_version" : %MAX_API_VER%,
258  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
259  "ledger_index" : 42
260  }
261  ]
262  })"},
263  {"account_currencies: validated ledger.",
264  __LINE__,
265  {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
266  RPCCallTestData::no_exception,
267  R"({
268  "method" : "account_currencies",
269  "params" : [
270  {
271  "api_version" : %MAX_API_VER%,
272  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
273  "ledger_index" : "validated"
274  }
275  ]
276  })"},
277  {"account_currencies: current ledger.",
278  __LINE__,
279  {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "current"},
280  RPCCallTestData::no_exception,
281  R"({
282  "method" : "account_currencies",
283  "params" : [
284  {
285  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
286  "api_version" : %MAX_API_VER%,
287  "ledger_index" : "current"
288  }
289  ]
290  })"},
291  {"account_currencies: too few arguments.",
292  __LINE__,
293  {
294  "account_currencies",
295  },
296  RPCCallTestData::no_exception,
297  R"({
298  "method" : "account_currencies",
299  "params" : [
300  {
301  "error" : "badSyntax",
302  "error_code" : 1,
303  "error_message" : "Syntax error."
304  }
305  ]
306  })"},
307  {"account_currencies: too many arguments.",
308  __LINE__,
309  {"account_currencies",
310  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
311  "current",
312  "spare1",
313  "spare2"},
314  RPCCallTestData::no_exception,
315  R"({
316  "method" : "account_currencies",
317  "params" : [
318  {
319  "error" : "badSyntax",
320  "error_code" : 1,
321  "error_message" : "Syntax error."
322  }
323  ]
324  })"},
325  {"account_currencies: invalid second argument.",
326  __LINE__,
327  {"account_currencies", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "yup"},
328  RPCCallTestData::no_exception,
329  R"({
330  "method" : "account_currencies",
331  "params" : [
332  {
333  "api_version" : %MAX_API_VER%,
334  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
335  "ledger_index" : 0
336  }
337  ]
338  })"},
339  {
340  "account_currencies: invalid accountID.",
341  __LINE__,
342  {
343  "account_currencies",
344  "", // Note: very few values are detected as bad!
345  },
346  RPCCallTestData::no_exception,
347  R"({
348  "method" : "account_currencies",
349  "params" : [
350  {
351  "error" : "actMalformed",
352  "error_code" : 35,
353  "error_message" : "Account malformed."
354  }
355  ]
356  })",
357  },
358 
359  // account_info
360  // ----------------------------------------------------------------
361  {"account_info: minimal.",
362  __LINE__,
363  {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
364  RPCCallTestData::no_exception,
365  R"({
366  "method" : "account_info",
367  "params" : [
368  {
369  "api_version" : %MAX_API_VER%,
370  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
371  }
372  ]
373  })"},
374  {"account_info: with numeric ledger index.",
375  __LINE__,
376  {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "77777"},
377  RPCCallTestData::no_exception,
378  R"({
379  "method" : "account_info",
380  "params" : [
381  {
382  "api_version" : %MAX_API_VER%,
383  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
384  "ledger_index" : 77777
385  }
386  ]
387  })"},
388  {"account_info: with text ledger index.",
389  __LINE__,
390  {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "closed"},
391  RPCCallTestData::no_exception,
392  R"({
393  "method" : "account_info",
394  "params" : [
395  {
396  "api_version" : %MAX_API_VER%,
397  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
398  "ledger_index" : "closed"
399  }
400  ]
401  })"},
402  {"account_info: with ledger hash.",
403  __LINE__,
404  {"account_info",
405  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
406  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
407  RPCCallTestData::no_exception,
408  R"({
409  "method" : "account_info",
410  "params" : [
411  {
412  "api_version" : %MAX_API_VER%,
413  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
414  "ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
415  }
416  ]
417  })"},
418  {"account_info: with ledger index.",
419  __LINE__,
420  {"account_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
421  RPCCallTestData::no_exception,
422  R"({
423  "method" : "account_info",
424  "params" : [
425  {
426  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
427  "api_version" : %MAX_API_VER%,
428  "ledger_index" : "validated"
429  }
430  ]
431  })"},
432  {"account_info: too few arguments.",
433  __LINE__,
434  {
435  "account_info",
436  },
437  RPCCallTestData::no_exception,
438  R"({
439  "method" : "account_info",
440  "params" : [
441  {
442  "error" : "badSyntax",
443  "error_code" : 1,
444  "error_message" : "Syntax error."
445  }
446  ]
447  })"},
448  {"account_info: too many arguments.",
449  __LINE__,
450  {"account_info",
451  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
452  "current",
453  "extra1",
454  "extra2"},
455  RPCCallTestData::no_exception,
456  R"({
457  "method" : "account_info",
458  "params" : [
459  {
460  "error" : "badSyntax",
461  "error_code" : 1,
462  "error_message" : "Syntax error."
463  }
464  ]
465  })"},
466  {
467  "account_info: invalid accountID.",
468  __LINE__,
469  {
470  "account_info",
471  "", // Note: very few values are detected as bad!
472  },
473  RPCCallTestData::no_exception,
474  R"({
475  "method" : "account_info",
476  "params" : [
477  {
478  "error" : "actMalformed",
479  "error_code" : 35,
480  "error_message" : "Account malformed."
481  }
482  ]
483  })",
484  },
485 
486  // account_lines
487  // ---------------------------------------------------------------
488  {"account_lines: minimal.",
489  __LINE__,
490  {"account_lines", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
491  RPCCallTestData::no_exception,
492  R"({
493  "method" : "account_lines",
494  "params" : [
495  {
496  "api_version" : %MAX_API_VER%,
497  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
498  }
499  ]
500  })"},
501  {"account_lines: peer.",
502  __LINE__,
503  {"account_lines",
504  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
505  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
506  RPCCallTestData::no_exception,
507  R"({
508  "method" : "account_lines",
509  "params" : [
510  {
511  "api_version" : %MAX_API_VER%,
512  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
513  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
514  }
515  ]
516  })"},
517  {"account_lines: peer and numeric ledger index.",
518  __LINE__,
519  {"account_lines",
520  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
521  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
522  "888888888"},
523  RPCCallTestData::no_exception,
524  R"({
525  "method" : "account_lines",
526  "params" : [
527  {
528  "api_version" : %MAX_API_VER%,
529  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
530  "ledger_index" : 888888888,
531  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
532  }
533  ]
534  })"},
535  {"account_lines: peer and text ledger index.",
536  __LINE__,
537  {"account_lines",
538  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
539  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
540  "closed"},
541  RPCCallTestData::no_exception,
542  R"({
543  "method" : "account_lines",
544  "params" : [
545  {
546  "api_version" : %MAX_API_VER%,
547  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
548  "ledger_index" : "closed",
549  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
550  }
551  ]
552  })"},
553  {"account_lines: peer and ledger hash.",
554  __LINE__,
555  {"account_lines",
556  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
557  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
558  "FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000"},
559  RPCCallTestData::no_exception,
560  R"({
561  "method" : "account_lines",
562  "params" : [
563  {
564  "api_version" : %MAX_API_VER%,
565  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
566  "ledger_hash" : "FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000",
567  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
568  }
569  ]
570  })"},
571  {"account_lines: too few arguments.",
572  __LINE__,
573  {
574  "account_lines",
575  },
576  RPCCallTestData::no_exception,
577  R"({
578  "method" : "account_lines",
579  "params" : [
580  {
581  "error" : "badSyntax",
582  "error_code" : 1,
583  "error_message" : "Syntax error."
584  }
585  ]
586  })"},
587  {// Note: I believe this _ought_ to be detected as too many arguments.
588  "account_lines: four arguments.",
589  __LINE__,
590  {"account_lines",
591  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
592  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
593  "12345678",
594  "current"},
595  RPCCallTestData::no_exception,
596  R"({
597  "method" : "account_lines",
598  "params" : [
599  {
600  "api_version" : %MAX_API_VER%,
601  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
602  "ledger_index" : 12345678,
603  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
604  }
605  ]
606  })"},
607  {// Note: I believe this _ought_ to be detected as too many arguments.
608  "account_lines: five arguments.",
609  __LINE__,
610  {"account_lines",
611  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
612  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
613  "12345678",
614  "current",
615  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
616  RPCCallTestData::no_exception,
617  R"({
618  "method" : "account_lines",
619  "params" : [
620  {
621  "api_version" : %MAX_API_VER%,
622  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
623  "ledger_index" : 12345678,
624  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
625  }
626  ]
627  })"},
628  {"account_lines: too many arguments.",
629  __LINE__,
630  {"account_lines",
631  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
632  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
633  "12345678",
634  "current",
635  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
636  "validated"},
637  RPCCallTestData::no_exception,
638  R"({
639  "method" : "account_lines",
640  "params" : [
641  {
642  "error" : "badSyntax",
643  "error_code" : 1,
644  "error_message" : "Syntax error."
645  }
646  ]
647  })"},
648  {
649  "account_lines: first invalid accountID.",
650  __LINE__,
651  {
652  "account_lines",
653  "", // Note: very few values are detected as bad!
654  },
655  RPCCallTestData::no_exception,
656  R"({
657  "method" : "account_lines",
658  "params" : [
659  {
660  "error" : "actMalformed",
661  "error_code" : 35,
662  "error_message" : "Account malformed."
663  }
664  ]
665  })",
666  },
667  {
668  "account_lines: second invalid accountID.",
669  __LINE__,
670  {
671  "account_lines",
672  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
673  "" // Note: very few values are detected as bad!
674  },
675  RPCCallTestData::no_exception,
676  R"({
677  "method" : "account_lines",
678  "params" : [
679  {
680  "api_version" : %MAX_API_VER%,
681  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
682  }
683  ]
684  })",
685  },
686  {
687  "account_lines: invalid ledger selector.",
688  __LINE__,
689  {"account_lines",
690  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
691  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
692  "not_a_ledger"},
693  RPCCallTestData::no_exception,
694  R"({
695  "method" : "account_lines",
696  "params" : [
697  {
698  "api_version" : %MAX_API_VER%,
699  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
700  "ledger_index" : 0,
701  "peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
702  }
703  ]
704  })",
705  },
706 
707  // account_objects
708  // -------------------------------------------------------------
709  {"account_objects: minimal.",
710  __LINE__,
711  {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
712  RPCCallTestData::no_exception,
713  R"({
714  "method" : "account_objects",
715  "params" : [
716  {
717  "api_version" : %MAX_API_VER%,
718  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
719  }
720  ]
721  })"},
722  {"account_objects: with numeric ledger index.",
723  __LINE__,
724  {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "77777"},
725  RPCCallTestData::no_exception,
726  R"({
727  "method" : "account_objects",
728  "params" : [
729  {
730  "api_version" : %MAX_API_VER%,
731  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
732  "ledger_index" : 77777
733  }
734  ]
735  })"},
736  {"account_objects: with text ledger index.",
737  __LINE__,
738  {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "closed"},
739  RPCCallTestData::no_exception,
740  R"({
741  "method" : "account_objects",
742  "params" : [
743  {
744  "api_version" : %MAX_API_VER%,
745  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
746  "ledger_index" : "closed"
747  }
748  ]
749  })"},
750  {"account_objects: with ledger hash.",
751  __LINE__,
752  {"account_objects",
753  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
754  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
755  RPCCallTestData::no_exception,
756  R"({
757  "method" : "account_objects",
758  "params" : [
759  {
760  "api_version" : %MAX_API_VER%,
761  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
762  "ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
763  }
764  ]
765  })"},
766  {"account_objects: with ledger index.",
767  __LINE__,
768  {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
769  RPCCallTestData::no_exception,
770  R"({
771  "method" : "account_objects",
772  "params" : [
773  {
774  "api_version" : %MAX_API_VER%,
775  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
776  "ledger_index" : "validated"
777  }
778  ]
779  })"},
780  {"account_objects: too few arguments.",
781  __LINE__,
782  {
783  "account_objects",
784  },
785  RPCCallTestData::no_exception,
786  R"({
787  "method" : "account_objects",
788  "params" : [
789  {
790  "error" : "badSyntax",
791  "error_code" : 1,
792  "error_message" : "Syntax error."
793  }
794  ]
795  })"},
796  {// Note: I believe this _ought_ to be detected as too many arguments.
797  "account_objects: four arguments.",
798  __LINE__,
799  {
800  "account_objects",
801  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
802  "current",
803  "extra1",
804  "extra2",
805  },
806  RPCCallTestData::no_exception,
807  R"({
808  "method" : "account_objects",
809  "params" : [
810  {
811  "api_version" : %MAX_API_VER%,
812  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
813  }
814  ]
815  })"},
816  {// Note: I believe this _ought_ to be detected as too many arguments.
817  "account_objects: five arguments.",
818  __LINE__,
819  {
820  "account_objects",
821  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
822  "current",
823  "extra1",
824  "extra2",
825  "extra3",
826  },
827  RPCCallTestData::no_exception,
828  R"({
829  "method" : "account_objects",
830  "params" : [
831  {
832  "api_version" : %MAX_API_VER%,
833  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
834  }
835  ]
836  })"},
837  {"account_objects: too many arguments.",
838  __LINE__,
839  {
840  "account_objects",
841  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
842  "current",
843  "extra1",
844  "extra2",
845  "extra3",
846  "extra4",
847  },
848  RPCCallTestData::no_exception,
849  R"({
850  "method" : "account_objects",
851  "params" : [
852  {
853  "error" : "badSyntax",
854  "error_code" : 1,
855  "error_message" : "Syntax error."
856  }
857  ]
858  })"},
859  {
860  "account_objects: invalid accountID.",
861  __LINE__,
862  {
863  "account_objects",
864  "", // Note: very few values are detected as bad!
865  },
866  RPCCallTestData::no_exception,
867  R"({
868  "method" : "account_objects",
869  "params" : [
870  {
871  "error" : "actMalformed",
872  "error_code" : 35,
873  "error_message" : "Account malformed."
874  }
875  ]
876  })",
877  },
878  {
879  // Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
880  // cannot currently occur because jvParseLedger() always returns true.
881  "account_objects: invalid ledger selection 1.",
882  __LINE__,
883  {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
884  RPCCallTestData::no_exception,
885  R"({
886  "method" : "account_objects",
887  "params" : [
888  {
889  "api_version" : %MAX_API_VER%,
890  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
891  "ledger_index" : 0
892  }
893  ]
894  })",
895  },
896  {
897  // Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
898  // cannot currently occur because jvParseLedger() always returns true.
899  "account_objects: invalid ledger selection 2.",
900  __LINE__,
901  {"account_objects", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
902  RPCCallTestData::no_exception,
903  R"({
904  "method" : "account_objects",
905  "params" : [
906  {
907  "api_version" : %MAX_API_VER%,
908  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
909  "ledger_index" : 0
910  }
911  ]
912  })",
913  },
914 
915  // account_offers
916  // --------------------------------------------------------------
917  {"account_offers: minimal.",
918  __LINE__,
919  {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
920  RPCCallTestData::no_exception,
921  R"({
922  "method" : "account_offers",
923  "params" : [
924  {
925  "api_version" : %MAX_API_VER%,
926  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
927  }
928  ]
929  })"},
930  {"account_offers: with numeric ledger index.",
931  __LINE__,
932  {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "987654321"},
933  RPCCallTestData::no_exception,
934  R"({
935  "method" : "account_offers",
936  "params" : [
937  {
938  "api_version" : %MAX_API_VER%,
939  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
940  "ledger_index" : 987654321
941  }
942  ]
943  })"},
944  {"account_offers: with text ledger index.",
945  __LINE__,
946  {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
947  RPCCallTestData::no_exception,
948  R"({
949  "method" : "account_offers",
950  "params" : [
951  {
952  "api_version" : %MAX_API_VER%,
953  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
954  "ledger_index" : "validated"
955  }
956  ]
957  })"},
958  {"account_offers: with ledger hash.",
959  __LINE__,
960  {"account_offers",
961  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
962  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
963  RPCCallTestData::no_exception,
964  R"({
965  "method" : "account_offers",
966  "params" : [
967  {
968  "api_version" : %MAX_API_VER%,
969  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
970  "ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
971  }
972  ]
973  })"},
974  {"account_offers: with ledger index.",
975  __LINE__,
976  {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
977  RPCCallTestData::no_exception,
978  R"({
979  "method" : "account_offers",
980  "params" : [
981  {
982  "api_version" : %MAX_API_VER%,
983  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
984  "ledger_index" : "validated"
985  }
986  ]
987  })"},
988  {"account_offers: too few arguments.",
989  __LINE__,
990  {
991  "account_offers",
992  },
993  RPCCallTestData::no_exception,
994  R"({
995  "method" : "account_offers",
996  "params" : [
997  {
998  "error" : "badSyntax",
999  "error_code" : 1,
1000  "error_message" : "Syntax error."
1001  }
1002  ]
1003  })"},
1004  {// Note: I believe this _ought_ to be detected as too many arguments.
1005  "account_offers: four arguments.",
1006  __LINE__,
1007  {"account_offers",
1008  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1009  "current",
1010  "extra"},
1011  RPCCallTestData::no_exception,
1012  R"({
1013  "method" : "account_offers",
1014  "params" : [
1015  {
1016  "api_version" : %MAX_API_VER%,
1017  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
1018  }
1019  ]
1020  })"},
1021  {"account_offers: too many arguments.",
1022  __LINE__,
1023  {
1024  "account_offers",
1025  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1026  "current",
1027  "extra1",
1028  "extra2",
1029  "extra3",
1030  },
1031  RPCCallTestData::no_exception,
1032  R"({
1033  "method" : "account_offers",
1034  "params" : [
1035  {
1036  "error" : "badSyntax",
1037  "error_code" : 1,
1038  "error_message" : "Syntax error."
1039  }
1040  ]
1041  })"},
1042  {
1043  "account_offers: invalid accountID.",
1044  __LINE__,
1045  {
1046  "account_offers",
1047  "", // Note: very few values are detected as bad!
1048  },
1049  RPCCallTestData::no_exception,
1050  R"({
1051  "method" : "account_offers",
1052  "params" : [
1053  {
1054  "error" : "actMalformed",
1055  "error_code" : 35,
1056  "error_message" : "Account malformed."
1057  }
1058  ]
1059  })",
1060  },
1061  {
1062  // Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
1063  // cannot currently occur because jvParseLedger() always returns true.
1064  "account_offers: invalid ledger selection 1.",
1065  __LINE__,
1066  {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
1067  RPCCallTestData::no_exception,
1068  R"({
1069  "method" : "account_offers",
1070  "params" : [
1071  {
1072  "api_version" : %MAX_API_VER%,
1073  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1074  "ledger_index" : 0
1075  }
1076  ]
1077  })",
1078  },
1079  {
1080  // Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
1081  // cannot currently occur because jvParseLedger() always returns true.
1082  "account_offers: invalid ledger selection 2.",
1083  __LINE__,
1084  {"account_offers", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
1085  RPCCallTestData::no_exception,
1086  R"({
1087  "method" : "account_offers",
1088  "params" : [
1089  {
1090  "api_version" : %MAX_API_VER%,
1091  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1092  "ledger_index" : 0
1093  }
1094  ]
1095  })",
1096  },
1097 
1098  // account_tx
1099  // ------------------------------------------------------------------
1100  {"account_tx: minimal.",
1101  __LINE__,
1102  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
1103  RPCCallTestData::no_exception,
1104  R"({
1105  "method" : "account_tx",
1106  "params" : [
1107  {
1108  "api_version" : %MAX_API_VER%,
1109  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1110  }
1111  ]
1112  })"},
1113  {"account_tx: ledger_index .",
1114  __LINE__,
1115  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "444"},
1116  RPCCallTestData::no_exception,
1117  R"({
1118  "method" : "account_tx",
1119  "params" : [
1120  {
1121  "api_version" : %MAX_API_VER%,
1122  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1123  "ledger_index" : 444
1124  }
1125  ]
1126  })"},
1127  {"account_tx: ledger_index plus trailing params.",
1128  __LINE__,
1129  {"account_tx",
1130  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1131  "707",
1132  "descending",
1133  "binary",
1134  "count"},
1135  RPCCallTestData::no_exception,
1136  R"({
1137  "method" : "account_tx",
1138  "params" : [
1139  {
1140  "api_version" : %MAX_API_VER%,
1141  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1142  "count" : true,
1143  "binary" : true,
1144  "descending" : true,
1145  "ledger_index" : 707
1146  }
1147  ]
1148  })"},
1149  {"account_tx: ledger_index_min and _max.",
1150  __LINE__,
1151  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "-1"},
1152  RPCCallTestData::no_exception,
1153  R"({
1154  "method" : "account_tx",
1155  "params" : [
1156  {
1157  "api_version" : %MAX_API_VER%,
1158  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1159  "ledger_index_max" : -1,
1160  "ledger_index_min" : -1
1161  }
1162  ]
1163  })"},
1164  {"account_tx: ledger_index_min and _max plus trailing params.",
1165  __LINE__,
1166  {"account_tx",
1167  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1168  "-1",
1169  "413",
1170  "binary",
1171  "count",
1172  "descending"},
1173  RPCCallTestData::no_exception,
1174  R"({
1175  "method" : "account_tx",
1176  "params" : [
1177  {
1178  "api_version" : %MAX_API_VER%,
1179  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1180  "binary" : true,
1181  "count" : true,
1182  "descending" : true,
1183  "ledger_index_max" : 413,
1184  "ledger_index_min" : -1
1185  }
1186  ]
1187  })"},
1188  {"account_tx: ledger_index_min and _max plus limit.",
1189  __LINE__,
1190  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "247", "-1", "300"},
1191  RPCCallTestData::no_exception,
1192  R"({
1193  "method" : "account_tx",
1194  "params" : [
1195  {
1196  "api_version" : %MAX_API_VER%,
1197  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1198  "ledger_index_max" : -1,
1199  "ledger_index_min" : 247,
1200  "limit" : 300
1201  }
1202  ]
1203  })"},
1204  {"account_tx: ledger_index_min and _max, limit, trailing args.",
1205  __LINE__,
1206  {"account_tx",
1207  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1208  "247",
1209  "-1",
1210  "300",
1211  "count",
1212  "descending",
1213  "binary"},
1214  RPCCallTestData::no_exception,
1215  R"({
1216  "method" : "account_tx",
1217  "params" : [
1218  {
1219  "api_version" : %MAX_API_VER%,
1220  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1221  "binary" : true,
1222  "count" : true,
1223  "descending" : true,
1224  "ledger_index_max" : -1,
1225  "ledger_index_min" : 247,
1226  "limit" : 300
1227  }
1228  ]
1229  })"},
1230  {"account_tx: ledger_index_min and _max plus limit and offset.",
1231  __LINE__,
1232  {"account_tx",
1233  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1234  "589",
1235  "590",
1236  "67",
1237  "45"},
1238  RPCCallTestData::no_exception,
1239  R"({
1240  "method" : "account_tx",
1241  "params" : [
1242  {
1243  "api_version" : %MAX_API_VER%,
1244  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1245  "ledger_index_max" : 590,
1246  "ledger_index_min" : 589,
1247  "limit" : 67,
1248  "offset" : 45
1249  }
1250  ]
1251  })"},
1252  {"account_tx: ledger_index_min and _max, limit, offset, trailing.",
1253  __LINE__,
1254  {"account_tx",
1255  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1256  "589",
1257  "590",
1258  "67",
1259  "45",
1260  "descending",
1261  "count"},
1262  RPCCallTestData::no_exception,
1263  R"({
1264  "method" : "account_tx",
1265  "params" : [
1266  {
1267  "api_version" : %MAX_API_VER%,
1268  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1269  "count" : true,
1270  "descending" : true,
1271  "ledger_index_max" : 590,
1272  "ledger_index_min" : 589,
1273  "limit" : 67,
1274  "offset" : 45
1275  }
1276  ]
1277  })"},
1278  {"account_tx: too few arguments.",
1279  __LINE__,
1280  {
1281  "account_tx",
1282  },
1283  RPCCallTestData::no_exception,
1284  R"({
1285  "method" : "account_tx",
1286  "params" : [
1287  {
1288  "error" : "badSyntax",
1289  "error_code" : 1,
1290  "error_message" : "Syntax error."
1291  }
1292  ]
1293  })"},
1294  {"account_tx: too many arguments.",
1295  __LINE__,
1296  {"account_tx",
1297  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1298  "589",
1299  "590",
1300  "67",
1301  "45",
1302  "extra",
1303  "descending",
1304  "count",
1305  "binary"},
1306  RPCCallTestData::no_exception,
1307  R"({
1308  "method" : "account_tx",
1309  "params" : [
1310  {
1311  "error" : "badSyntax",
1312  "error_code" : 1,
1313  "error_message" : "Syntax error."
1314  }
1315  ]
1316  })"},
1317  {
1318  "account_tx: invalid accountID.",
1319  __LINE__,
1320  {"account_tx", "rHb9CJAWyB4rj9!VRWn96DkukG4bwdtyTh"},
1321  RPCCallTestData::no_exception,
1322  R"({
1323  "method" : "account_tx",
1324  "params" : [
1325  {
1326  "error" : "actMalformed",
1327  "error_code" : 35,
1328  "error_message" : "Account malformed."
1329  }
1330  ]
1331  })",
1332  },
1333  {
1334  // Note: not currently detected as bad input.
1335  "account_tx: invalid ledger.",
1336  __LINE__,
1337  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-478.7"},
1338  RPCCallTestData::no_exception,
1339  R"({
1340  "method" : "account_tx",
1341  "params" : [
1342  {
1343  "api_version" : %MAX_API_VER%,
1344  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1345  "ledger_index" : 0
1346  }
1347  ]
1348  })",
1349  },
1350  {
1351  "account_tx: max less than min.",
1352  __LINE__,
1353  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "580", "579"},
1354  RPCCallTestData::no_exception,
1355  RPC::apiMaximumSupportedVersion == 1 ?
1356  R"({
1357  "method" : "account_tx",
1358  "params" : [
1359  {
1360  "error" : "lgrIdxsInvalid",
1361  "error_code" : 55,
1362  "error_message" : "Ledger indexes invalid."
1363  }
1364  ]
1365  })"
1366  :
1367  R"({
1368  "method" : "account_tx",
1369  "params" : [
1370  {
1371  "error" : "notSynced",
1372  "error_code" : 55,
1373  "error_message" : "Not synced to the network."
1374  }
1375  ]
1376  })",
1377  },
1378  {
1379  // Note: this really shouldn't throw, but does at the moment.
1380  "account_tx: non-integer min.",
1381  __LINE__,
1382  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "Binary", "-1"},
1383  RPCCallTestData::bad_cast,
1384  R"()",
1385  },
1386  {
1387  // Note: this really shouldn't throw, but does at the moment.
1388  "account_tx: non-integer max.",
1389  __LINE__,
1390  {"account_tx", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "counts"},
1391  RPCCallTestData::bad_cast,
1392  R"()",
1393  },
1394  {
1395  // Note: this really shouldn't throw, but does at the moment.
1396  "account_tx: non-integer offset.",
1397  __LINE__,
1398  {"account_tx",
1399  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1400  "-1",
1401  "-1",
1402  "decending"},
1403  RPCCallTestData::bad_cast,
1404  R"()",
1405  },
1406  {
1407  // Note: this really shouldn't throw, but does at the moment.
1408  "account_tx: non-integer limit.",
1409  __LINE__,
1410  {"account_tx",
1411  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1412  "-1",
1413  "-1",
1414  "300",
1415  "false"},
1416  RPCCallTestData::bad_cast,
1417  R"()",
1418  },
1419  {// Note: this really shouldn't throw, but does at the moment.
1420  "account_tx: RIPD-1570.",
1421  __LINE__,
1422  {"account_tx",
1423  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1424  "-1",
1425  "-1",
1426  "2",
1427  "false",
1428  "false",
1429  "false"},
1430  RPCCallTestData::bad_cast,
1431  R"()"},
1432 
1433  // book_offers
1434  // -----------------------------------------------------------------
1435  {"book_offers: minimal no issuer.",
1436  __LINE__,
1437  {
1438  "book_offers",
1439  "USD",
1440  "EUR",
1441  },
1442  RPCCallTestData::no_exception,
1443  R"({
1444  "method" : "book_offers",
1445  "params" : [
1446  {
1447  "api_version" : %MAX_API_VER%,
1448  "taker_gets" : {
1449  "currency" : "EUR"
1450  },
1451  "taker_pays" : {
1452  "currency" : "USD"
1453  }
1454  }
1455  ]
1456  })"},
1457  {"book_offers: minimal with currency/issuer",
1458  __LINE__,
1459  {
1460  "book_offers",
1461  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1462  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1463  },
1464  RPCCallTestData::no_exception,
1465  R"({
1466  "method" : "book_offers",
1467  "params" : [
1468  {
1469  "api_version" : %MAX_API_VER%,
1470  "taker_gets" : {
1471  "currency" : "EUR",
1472  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
1473  },
1474  "taker_pays" : {
1475  "currency" : "USD",
1476  "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
1477  }
1478  }
1479  ]
1480  })"},
1481  {// Note: documentation suggests that "issuer" is the wrong type.
1482  // Should it be "taker" instead?
1483  "book_offers: add issuer.",
1484  __LINE__,
1485  {"book_offers", "USD", "EUR", "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"},
1486  RPCCallTestData::no_exception,
1487  R"({
1488  "method" : "book_offers",
1489  "params" : [
1490  {
1491  "api_version" : %MAX_API_VER%,
1492  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1493  "taker_gets" : {
1494  "currency" : "EUR"
1495  },
1496  "taker_pays" : {
1497  "currency" : "USD"
1498  }
1499  }
1500  ]
1501  })"},
1502  {"book_offers: add issuer and numeric ledger index.",
1503  __LINE__,
1504  {"book_offers",
1505  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1506  "EUR",
1507  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1508  "666"},
1509  RPCCallTestData::no_exception,
1510  R"({
1511  "method" : "book_offers",
1512  "params" : [
1513  {
1514  "api_version" : %MAX_API_VER%,
1515  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1516  "ledger_index" : 666,
1517  "taker_gets" : {
1518  "currency" : "EUR"
1519  },
1520  "taker_pays" : {
1521  "currency" : "USD",
1522  "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
1523  }
1524  }
1525  ]
1526  })"},
1527  {"book_offers: add issuer and text ledger index.",
1528  __LINE__,
1529  {"book_offers",
1530  "USD",
1531  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1532  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1533  "current"},
1534  RPCCallTestData::no_exception,
1535  R"({
1536  "method" : "book_offers",
1537  "params" : [
1538  {
1539  "api_version" : %MAX_API_VER%,
1540  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1541  "ledger_index" : "current",
1542  "taker_gets" : {
1543  "currency" : "EUR",
1544  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
1545  },
1546  "taker_pays" : {
1547  "currency" : "USD"
1548  }
1549  }
1550  ]
1551  })"},
1552  {"book_offers: add issuer and ledger hash.",
1553  __LINE__,
1554  {"book_offers",
1555  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1556  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1557  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1558  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
1559  RPCCallTestData::no_exception,
1560  R"({
1561  "method" : "book_offers",
1562  "params" : [
1563  {
1564  "api_version" : %MAX_API_VER%,
1565  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1566  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1567  "taker_gets" : {
1568  "currency" : "EUR",
1569  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
1570  },
1571  "taker_pays" : {
1572  "currency" : "USD",
1573  "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
1574  }
1575  }
1576  ]
1577  })"},
1578  {"book_offers: issuer, ledger hash, and limit.",
1579  __LINE__,
1580  {
1581  "book_offers",
1582  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1583  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1584  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1585  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1586  "junk", // Note: indexing bug in parseBookOffers() requires junk
1587  // param.
1588  "200",
1589  },
1590  RPCCallTestData::no_exception,
1591  R"({
1592  "method" : "book_offers",
1593  "params" : [
1594  {
1595  "api_version" : %MAX_API_VER%,
1596  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1597  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1598  "limit" : 200,
1599  "proof" : true,
1600  "taker_gets" : {
1601  "currency" : "EUR",
1602  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
1603  },
1604  "taker_pays" : {
1605  "currency" : "USD",
1606  "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
1607  }
1608  }
1609  ]
1610  })"},
1611  {// Note: parser supports "marker", but the docs don't cover it.
1612  "book_offers: issuer, ledger hash, limit, and marker.",
1613  __LINE__,
1614  {"book_offers",
1615  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1616  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1617  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1618  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1619  "junk", // Note: indexing bug in parseBookOffers() requires junk param.
1620  "200",
1621  "MyMarker"},
1622  RPCCallTestData::no_exception,
1623  R"({
1624  "method" : "book_offers",
1625  "params" : [
1626  {
1627  "api_version" : %MAX_API_VER%,
1628  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1629  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1630  "limit" : 200,
1631  "marker" : "MyMarker",
1632  "proof" : true,
1633  "taker_gets" : {
1634  "currency" : "EUR",
1635  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
1636  },
1637  "taker_pays" : {
1638  "currency" : "USD",
1639  "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
1640  }
1641  }
1642  ]
1643  })"},
1644  {"book_offers: too few arguments.",
1645  __LINE__,
1646  {
1647  "book_offers",
1648  },
1649  RPCCallTestData::no_exception,
1650  R"({
1651  "method" : "book_offers",
1652  "params" : [
1653  {
1654  "error" : "badSyntax",
1655  "error_code" : 1,
1656  "error_message" : "Syntax error."
1657  }
1658  ]
1659  })"},
1660  {"book_offers: too many arguments.",
1661  __LINE__,
1662  {"book_offers",
1663  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1664  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1665  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1666  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1667  "junk", // Note: indexing bug in parseBookOffers() requires junk param.
1668  "200",
1669  "MyMarker",
1670  "extra"},
1671  RPCCallTestData::no_exception,
1672  R"({
1673  "method" : "book_offers",
1674  "params" : [
1675  {
1676  "error" : "badSyntax",
1677  "error_code" : 1,
1678  "error_message" : "Syntax error."
1679  }
1680  ]
1681  })"},
1682 
1683  {"book_offers: taker pays no currency.",
1684  __LINE__,
1685  {
1686  "book_offers",
1687  "/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1688  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1689  },
1690  RPCCallTestData::no_exception,
1691  R"({
1692  "method" : "book_offers",
1693  "params" : [
1694  {
1695  "error" : "invalidParams",
1696  "error_code" : 31,
1697  "error_message" : "Invalid currency/issuer '/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'"
1698  }
1699  ]
1700  })"},
1701  {"book_offers: taker gets no currency.",
1702  __LINE__,
1703  {
1704  "book_offers",
1705  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1706  "/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1707  },
1708  RPCCallTestData::no_exception,
1709  R"({
1710  "method" : "book_offers",
1711  "params" : [
1712  {
1713  "error" : "invalidParams",
1714  "error_code" : 31,
1715  "error_message" : "Invalid currency/issuer '/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA'"
1716  }
1717  ]
1718  })"},
1719  {"book_offers: invalid issuer.",
1720  __LINE__,
1721  {"book_offers", "USD", "EUR", "not_a_valid_issuer"},
1722  RPCCallTestData::no_exception,
1723  R"({
1724  "method" : "book_offers",
1725  "params" : [
1726  {
1727  "api_version" : %MAX_API_VER%,
1728  "issuer" : "not_a_valid_issuer",
1729  "taker_gets" : {
1730  "currency" : "EUR"
1731  },
1732  "taker_pays" : {
1733  "currency" : "USD"
1734  }
1735  }
1736  ]
1737  })"},
1738  {"book_offers: invalid text ledger index.",
1739  __LINE__,
1740  {"book_offers",
1741  "USD",
1742  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1743  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1744  "not_a_ledger"},
1745  RPCCallTestData::no_exception,
1746  R"({
1747  "method" : "book_offers",
1748  "params" : [
1749  {
1750  "api_version" : %MAX_API_VER%,
1751  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1752  "ledger_index" : 0,
1753  "taker_gets" : {
1754  "currency" : "EUR",
1755  "issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
1756  },
1757  "taker_pays" : {
1758  "currency" : "USD"
1759  }
1760  }
1761  ]
1762  })"},
1763  {// Note: this really shouldn't throw, but does at the moment.
1764  "book_offers: non-numeric limit.",
1765  __LINE__,
1766  {
1767  "book_offers",
1768  "USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
1769  "EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1770  "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
1771  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
1772  "junk", // Note: indexing bug in parseBookOffers() requires junk
1773  // param.
1774  "not_a_number",
1775  },
1776  RPCCallTestData::bad_cast,
1777  R"()"},
1778 
1779  // can_delete
1780  // ------------------------------------------------------------------
1781  {"can_delete: minimal.",
1782  __LINE__,
1783  {
1784  "can_delete",
1785  },
1786  RPCCallTestData::no_exception,
1787  R"({
1788  "method" : "can_delete",
1789  "params" : [
1790  {
1791  "api_version" : %MAX_API_VER%,
1792  }
1793  ]
1794  })"},
1795  {"can_delete: ledger index.",
1796  __LINE__,
1797  {
1798  "can_delete",
1799  "4294967295",
1800  },
1801  RPCCallTestData::no_exception,
1802  R"({
1803  "method" : "can_delete",
1804  "params" : [
1805  {
1806  "api_version" : %MAX_API_VER%,
1807  "can_delete" : 4294967295
1808  }
1809  ]
1810  })"},
1811  {"can_delete: ledger hash.",
1812  __LINE__,
1813  {
1814  "can_delete",
1815  "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
1816  },
1817  RPCCallTestData::no_exception,
1818  R"({
1819  "method" : "can_delete",
1820  "params" : [
1821  {
1822  "api_version" : %MAX_API_VER%,
1823  "can_delete" : "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"
1824  }
1825  ]
1826  })"},
1827  {"can_delete: always.",
1828  __LINE__,
1829  {
1830  "can_delete",
1831  "always",
1832  },
1833  RPCCallTestData::no_exception,
1834  R"({
1835  "method" : "can_delete",
1836  "params" : [
1837  {
1838  "api_version" : %MAX_API_VER%,
1839  "can_delete" : "always"
1840  }
1841  ]
1842  })"},
1843  {"can_delete: never.",
1844  __LINE__,
1845  {
1846  "can_delete",
1847  "never",
1848  },
1849  RPCCallTestData::no_exception,
1850  R"({
1851  "method" : "can_delete",
1852  "params" : [
1853  {
1854  "api_version" : %MAX_API_VER%,
1855  "can_delete" : "never"
1856  }
1857  ]
1858  })"},
1859  {"can_delete: now.",
1860  __LINE__,
1861  {
1862  "can_delete",
1863  "now",
1864  },
1865  RPCCallTestData::no_exception,
1866  R"({
1867  "method" : "can_delete",
1868  "params" : [
1869  {
1870  "api_version" : %MAX_API_VER%,
1871  "can_delete" : "now"
1872  }
1873  ]
1874  })"},
1875  {"can_delete: too many arguments.",
1876  __LINE__,
1877  {"can_delete", "always", "never"},
1878  RPCCallTestData::no_exception,
1879  R"({
1880  "method" : "can_delete",
1881  "params" : [
1882  {
1883  "error" : "badSyntax",
1884  "error_code" : 1,
1885  "error_message" : "Syntax error."
1886  }
1887  ]
1888  })"},
1889  {"can_delete: invalid argument.",
1890  __LINE__,
1891  {"can_delete", "invalid"},
1892  RPCCallTestData::no_exception,
1893  R"({
1894  "method" : "can_delete",
1895  "params" : [
1896  {
1897  "api_version" : %MAX_API_VER%,
1898  "can_delete" : "invalid"
1899  }
1900  ]
1901  })"},
1902  {// Note: this should return an error but not throw.
1903  "can_delete: ledger index > 32 bits.",
1904  __LINE__,
1905  {
1906  "can_delete",
1907  "4294967296",
1908  },
1909  RPCCallTestData::bad_cast,
1910  R"()"},
1911  {// Note: this really shouldn't throw since it's a legitimate ledger hash.
1912  "can_delete: ledger hash with no alphas.",
1913  __LINE__,
1914  {
1915  "can_delete",
1916  "0123456701234567012345670123456701234567012345670123456701234567",
1917  },
1918  RPCCallTestData::bad_cast,
1919  R"()"},
1920 
1921  // channel_authorize
1922  // -----------------------------------------------------------
1923  {"channel_authorize: minimal.",
1924  __LINE__,
1925  {"channel_authorize",
1926  "secret_can_be_anything",
1927  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
1928  "18446744073709551615"},
1929  RPCCallTestData::no_exception,
1930  R"({
1931  "method" : "channel_authorize",
1932  "params" : [
1933  {
1934  "api_version" : %MAX_API_VER%,
1935  "amount" : "18446744073709551615",
1936  "channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
1937  "secret" : "secret_can_be_anything"
1938  }
1939  ]
1940  })"},
1941  {"channel_authorize: too few arguments.",
1942  __LINE__,
1943  {
1944  "channel_authorize",
1945  "secret_can_be_anything",
1946  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
1947  },
1948  RPCCallTestData::no_exception,
1949  R"({
1950  "method" : "channel_authorize",
1951  "params" : [
1952  {
1953  "error" : "badSyntax",
1954  "error_code" : 1,
1955  "error_message" : "Syntax error."
1956  }
1957  ]
1958  })"},
1959  {"channel_authorize: too many arguments.",
1960  __LINE__,
1961  {"channel_authorize",
1962  "secp256k1",
1963  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
1964  "2000",
1965  "whatever",
1966  "whenever"},
1967  RPCCallTestData::no_exception,
1968  R"({
1969  "method" : "channel_authorize",
1970  "params" : [
1971  {
1972  "error" : "badSyntax",
1973  "error_code" : 1,
1974  "error_message" : "Syntax error."
1975  }
1976  ]
1977  })"},
1978  {"channel_authorize: bad key type.",
1979  __LINE__,
1980  {"channel_authorize",
1981  "secp257k1",
1982  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
1983  "2000",
1984  "whatever"},
1985  RPCCallTestData::no_exception,
1986  R"({
1987  "method" : "channel_authorize",
1988  "params" : [
1989  {
1990  "error" : "badKeyType",
1991  "error_code" : 1,
1992  "error_message" : "Bad key type."
1993  }
1994  ]
1995  })"},
1996  {"channel_authorize: channel_id too short.",
1997  __LINE__,
1998  {"channel_authorize",
1999  "secret_can_be_anything",
2000  "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2001  "2000"},
2002  RPCCallTestData::no_exception,
2003  R"({
2004  "method" : "channel_authorize",
2005  "params" : [
2006  {
2007  "error" : "channelMalformed",
2008  "error_code" : 43,
2009  "error_message" : "Payment channel is malformed."
2010  }
2011  ]
2012  })"},
2013  {"channel_authorize: channel_id too long.",
2014  __LINE__,
2015  {"channel_authorize",
2016  "secret_can_be_anything",
2017  "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2018  "2000"},
2019  RPCCallTestData::no_exception,
2020  R"({
2021  "method" : "channel_authorize",
2022  "params" : [
2023  {
2024  "error" : "channelMalformed",
2025  "error_code" : 43,
2026  "error_message" : "Payment channel is malformed."
2027  }
2028  ]
2029  })"},
2030  {"channel_authorize: channel_id not hex.",
2031  __LINE__,
2032  {"channel_authorize",
2033  "secret_can_be_anything",
2034  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEZ",
2035  "2000"},
2036  RPCCallTestData::no_exception,
2037  R"({
2038  "method" : "channel_authorize",
2039  "params" : [
2040  {
2041  "error" : "channelMalformed",
2042  "error_code" : 43,
2043  "error_message" : "Payment channel is malformed."
2044  }
2045  ]
2046  })"},
2047  {"channel_authorize: negative amount.",
2048  __LINE__,
2049  {"channel_authorize",
2050  "secret_can_be_anything",
2051  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2052  "-1"},
2053  RPCCallTestData::no_exception,
2054  R"({
2055  "method" : "channel_authorize",
2056  "params" : [
2057  {
2058  "error" : "channelAmtMalformed",
2059  "error_code" : 44,
2060  "error_message" : "Payment channel amount is malformed."
2061  }
2062  ]
2063  })"},
2064  {"channel_authorize: amount > 64 bits.",
2065  __LINE__,
2066  {"channel_authorize",
2067  "secret_can_be_anything",
2068  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2069  "18446744073709551616"},
2070  RPCCallTestData::no_exception,
2071  R"({
2072  "method" : "channel_authorize",
2073  "params" : [
2074  {
2075  "error" : "channelAmtMalformed",
2076  "error_code" : 44,
2077  "error_message" : "Payment channel amount is malformed."
2078  }
2079  ]
2080  })"},
2081 
2082  // channel_verify
2083  // --------------------------------------------------------------
2084  {"channel_verify: public key.",
2085  __LINE__,
2086  {"channel_verify",
2087  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2088  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2089  "0",
2090  "DEADBEEF"},
2091  RPCCallTestData::no_exception,
2092  R"({
2093  "method" : "channel_verify",
2094  "params" : [
2095  {
2096  "api_version" : %MAX_API_VER%,
2097  "amount" : "0",
2098  "channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2099  "public_key" : "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2100  "signature" : "DEADBEEF"
2101  }
2102  ]
2103  })"},
2104  {"channel_verify: public key hex.",
2105  __LINE__,
2106  {"channel_verify",
2107  "021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
2108  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2109  "18446744073709551615",
2110  "DEADBEEF"},
2111  RPCCallTestData::no_exception,
2112  R"({
2113  "method" : "channel_verify",
2114  "params" : [
2115  {
2116  "api_version" : %MAX_API_VER%,
2117  "amount" : "18446744073709551615",
2118  "channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2119  "public_key" : "021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
2120  "signature" : "DEADBEEF"
2121  }
2122  ]
2123  })"},
2124  {"channel_verify: too few arguments.",
2125  __LINE__,
2126  {"channel_verify",
2127  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2128  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
2129  RPCCallTestData::no_exception,
2130  R"({
2131  "method" : "channel_verify",
2132  "params" : [
2133  {
2134  "error" : "badSyntax",
2135  "error_code" : 1,
2136  "error_message" : "Syntax error."
2137  }
2138  ]
2139  })"},
2140  {"channel_verify: too many arguments.",
2141  __LINE__,
2142  {"channel_verify",
2143  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2144  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2145  "2000",
2146  "DEADBEEF",
2147  "Whatever"},
2148  RPCCallTestData::no_exception,
2149  R"({
2150  "method" : "channel_verify",
2151  "params" : [
2152  {
2153  "error" : "badSyntax",
2154  "error_code" : 1,
2155  "error_message" : "Syntax error."
2156  }
2157  ]
2158  })"},
2159  {"channel_verify: malformed public key.",
2160  __LINE__,
2161  {"channel_verify",
2162  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9GoV",
2163  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2164  "2000",
2165  "DEADBEEF"},
2166  RPCCallTestData::no_exception,
2167  R"({
2168  "method" : "channel_verify",
2169  "params" : [
2170  {
2171  "error" : "publicMalformed",
2172  "error_code" : 60,
2173  "error_message" : "Public key is malformed."
2174  }
2175  ]
2176  })"},
2177  {"channel_verify: malformed hex public key.",
2178  __LINE__,
2179  {"channel_verify",
2180  "021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F",
2181  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2182  "2000",
2183  "DEADBEEF"},
2184  RPCCallTestData::no_exception,
2185  R"({
2186  "method" : "channel_verify",
2187  "params" : [
2188  {
2189  "error" : "publicMalformed",
2190  "error_code" : 60,
2191  "error_message" : "Public key is malformed."
2192  }
2193  ]
2194  })"},
2195  {"channel_verify: invalid channel id.",
2196  __LINE__,
2197  {"channel_verify",
2198  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2199  "10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2200  "2000",
2201  "DEADBEEF"},
2202  RPCCallTestData::no_exception,
2203  R"({
2204  "method" : "channel_verify",
2205  "params" : [
2206  {
2207  "error" : "channelMalformed",
2208  "error_code" : 43,
2209  "error_message" : "Payment channel is malformed."
2210  }
2211  ]
2212  })"},
2213  {"channel_verify: short channel id.",
2214  __LINE__,
2215  {"channel_verify",
2216  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2217  "123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2218  "2000",
2219  "DEADBEEF"},
2220  RPCCallTestData::no_exception,
2221  R"({
2222  "method" : "channel_verify",
2223  "params" : [
2224  {
2225  "error" : "channelMalformed",
2226  "error_code" : 43,
2227  "error_message" : "Payment channel is malformed."
2228  }
2229  ]
2230  })"},
2231  {"channel_verify: amount too small.",
2232  __LINE__,
2233  {"channel_verify",
2234  "021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
2235  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2236  "-1",
2237  "DEADBEEF"},
2238  RPCCallTestData::no_exception,
2239  R"({
2240  "method" : "channel_verify",
2241  "params" : [
2242  {
2243  "error" : "channelAmtMalformed",
2244  "error_code" : 44,
2245  "error_message" : "Payment channel amount is malformed."
2246  }
2247  ]
2248  })"},
2249  {"channel_verify: amount too large.",
2250  __LINE__,
2251  {"channel_verify",
2252  "021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
2253  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2254  "18446744073709551616",
2255  "DEADBEEF"},
2256  RPCCallTestData::no_exception,
2257  R"({
2258  "method" : "channel_verify",
2259  "params" : [
2260  {
2261  "error" : "channelAmtMalformed",
2262  "error_code" : 44,
2263  "error_message" : "Payment channel amount is malformed."
2264  }
2265  ]
2266  })"},
2267  {"channel_verify: non-hex signature.",
2268  __LINE__,
2269  {"channel_verify",
2270  "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2271  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2272  "40000000",
2273  "ThisIsNotHexadecimal"},
2274  RPCCallTestData::no_exception,
2275  R"({
2276  "method" : "channel_verify",
2277  "params" : [
2278  {
2279  "api_version" : %MAX_API_VER%,
2280  "amount" : "40000000",
2281  "channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
2282  "public_key" : "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
2283  "signature" : "ThisIsNotHexadecimal"
2284  }
2285  ]
2286  })"},
2287 
2288  // connect
2289  // ---------------------------------------------------------------------
2290  {"connect: minimal.",
2291  __LINE__,
2292  {
2293  "connect",
2294  "ThereIsNoCheckingOnTheIPFormat",
2295  },
2296  RPCCallTestData::no_exception,
2297  R"({
2298  "method" : "connect",
2299  "params" : [
2300  {
2301  "api_version" : %MAX_API_VER%,
2302  "ip" : "ThereIsNoCheckingOnTheIPFormat"
2303  }
2304  ]
2305  })"},
2306  {"connect: ip and port.",
2307  __LINE__,
2308  {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561"},
2309  RPCCallTestData::no_exception,
2310  R"({
2311  "method" : "connect",
2312  "params" : [
2313  {
2314  "api_version" : %MAX_API_VER%,
2315  "ip" : "ThereIsNoCheckingOnTheIPFormat",
2316  "port" : 6561
2317  }
2318  ]
2319  })"},
2320  {"connect: too few arguments.",
2321  __LINE__,
2322  {
2323  "connect",
2324  },
2325  RPCCallTestData::no_exception,
2326  R"({
2327  "method" : "connect",
2328  "params" : [
2329  {
2330  "error" : "badSyntax",
2331  "error_code" : 1,
2332  "error_message" : "Syntax error."
2333  }
2334  ]
2335  })"},
2336  {"connect: too many arguments.",
2337  __LINE__,
2338  {"connect", "ThereIsNoCheckingOnTheIPFormat", "6561", "extra"},
2339  RPCCallTestData::no_exception,
2340  R"({
2341  "method" : "connect",
2342  "params" : [
2343  {
2344  "error" : "badSyntax",
2345  "error_code" : 1,
2346  "error_message" : "Syntax error."
2347  }
2348  ]
2349  })"},
2350  {// Note: this should return an error but not throw.
2351  "connect: port too small.",
2352  __LINE__,
2353  {
2354  "connect",
2355  "ThereIsNoCheckingOnTheIPFormat",
2356  "-1",
2357  },
2358  RPCCallTestData::bad_cast,
2359  R"()"},
2360  {// Note: this should return an error but not throw.
2361  "connect: port too large.",
2362  __LINE__,
2363  {
2364  "connect",
2365  "ThereIsNoCheckingOnTheIPFormat",
2366  "4294967296",
2367  },
2368  RPCCallTestData::bad_cast,
2369  R"()"},
2370 
2371  // consensus_info
2372  // --------------------------------------------------------------
2373  {"consensus_info: minimal.",
2374  __LINE__,
2375  {
2376  "consensus_info",
2377  },
2378  RPCCallTestData::no_exception,
2379  R"({
2380  "method" : "consensus_info",
2381  "params" : [
2382  {
2383  "api_version" : %MAX_API_VER%
2384  }
2385  ]
2386  })"},
2387  {"consensus_info: too many arguments.",
2388  __LINE__,
2389  {"consensus_info", "whatever"},
2390  RPCCallTestData::no_exception,
2391  R"({
2392  "method" : "consensus_info",
2393  "params" : [
2394  {
2395  "error" : "badSyntax",
2396  "error_code" : 1,
2397  "error_message" : "Syntax error."
2398  }
2399  ]
2400  })"},
2401 
2402  // deposit_authorized
2403  // ----------------------------------------------------------
2404  {"deposit_authorized: minimal.",
2405  __LINE__,
2406  {
2407  "deposit_authorized",
2408  "source_account_NotValidated",
2409  "destination_account_NotValidated",
2410  },
2411  RPCCallTestData::no_exception,
2412  R"({
2413  "method" : "deposit_authorized",
2414  "params" : [
2415  {
2416  "api_version" : %MAX_API_VER%,
2417  "destination_account" : "destination_account_NotValidated",
2418  "source_account" : "source_account_NotValidated"
2419  }
2420  ]
2421  })"},
2422  {"deposit_authorized: with text ledger index.",
2423  __LINE__,
2424  {"deposit_authorized",
2425  "source_account_NotValidated",
2426  "destination_account_NotValidated",
2427  "validated"},
2428  RPCCallTestData::no_exception,
2429  R"({
2430  "method" : "deposit_authorized",
2431  "params" : [
2432  {
2433  "api_version" : %MAX_API_VER%,
2434  "destination_account" : "destination_account_NotValidated",
2435  "ledger_index" : "validated",
2436  "source_account" : "source_account_NotValidated"
2437  }
2438  ]
2439  })"},
2440  {"deposit_authorized: with ledger index.",
2441  __LINE__,
2442  {"deposit_authorized",
2443  "source_account_NotValidated",
2444  "destination_account_NotValidated",
2445  "4294967295"},
2446  RPCCallTestData::no_exception,
2447  R"({
2448  "method" : "deposit_authorized",
2449  "params" : [
2450  {
2451  "api_version" : %MAX_API_VER%,
2452  "destination_account" : "destination_account_NotValidated",
2453  "ledger_index" : 4294967295,
2454  "source_account" : "source_account_NotValidated"
2455  }
2456  ]
2457  })"},
2458  {"deposit_authorized: with ledger hash.",
2459  __LINE__,
2460  {"deposit_authorized",
2461  "source_account_NotValidated",
2462  "destination_account_NotValidated",
2463  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
2464  RPCCallTestData::no_exception,
2465  R"({
2466  "method" : "deposit_authorized",
2467  "params" : [
2468  {
2469  "api_version" : %MAX_API_VER%,
2470  "destination_account" : "destination_account_NotValidated",
2471  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
2472  "source_account" : "source_account_NotValidated"
2473  }
2474  ]
2475  })"},
2476  {"deposit_authorized: too few arguments.",
2477  __LINE__,
2478  {
2479  "deposit_authorized",
2480  "source_account_NotValidated",
2481  },
2482  RPCCallTestData::no_exception,
2483  R"({
2484  "method" : "deposit_authorized",
2485  "params" : [
2486  {
2487  "error" : "badSyntax",
2488  "error_code" : 1,
2489  "error_message" : "Syntax error."
2490  }
2491  ]
2492  })"},
2493  {"deposit_authorized: too many arguments.",
2494  __LINE__,
2495  {"deposit_authorized",
2496  "source_account_NotValidated",
2497  "destination_account_NotValidated",
2498  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
2499  "spare"},
2500  RPCCallTestData::no_exception,
2501  R"({
2502  "method" : "deposit_authorized",
2503  "params" : [
2504  {
2505  "error" : "badSyntax",
2506  "error_code" : 1,
2507  "error_message" : "Syntax error."
2508  }
2509  ]
2510  })"},
2511  {"deposit_authorized: invalid ledger selection.",
2512  __LINE__,
2513  {
2514  "deposit_authorized",
2515  "source_account_NotValidated",
2516  "destination_account_NotValidated",
2517  "NotALedger",
2518  },
2519  RPCCallTestData::no_exception,
2520  R"({
2521  "method" : "deposit_authorized",
2522  "params" : [
2523  {
2524  "api_version" : %MAX_API_VER%,
2525  "destination_account" : "destination_account_NotValidated",
2526  "ledger_index" : 0,
2527  "source_account" : "source_account_NotValidated"
2528  }
2529  ]
2530  })"},
2531 
2532  // download_shard
2533  // --------------------------------------------------------------
2534  {"download_shard: minimal.",
2535  __LINE__,
2536  {
2537  "download_shard",
2538  "20",
2539  "url_NotValidated",
2540  },
2541  RPCCallTestData::no_exception,
2542  R"({
2543  "method" : "download_shard",
2544  "params" : [
2545  {
2546  "api_version" : %MAX_API_VER%,
2547  "shards" : [
2548  {
2549  "index" : 20,
2550  "url" : "url_NotValidated"
2551  }
2552  ]
2553  }
2554  ]
2555  })"},
2556  {"download_shard:",
2557  __LINE__,
2558  {
2559  "download_shard",
2560  "20",
2561  "url_NotValidated",
2562  },
2563  RPCCallTestData::no_exception,
2564  R"({
2565  "method" : "download_shard",
2566  "params" : [
2567  {
2568  "api_version" : %MAX_API_VER%,
2569  "shards" : [
2570  {
2571  "index" : 20,
2572  "url" : "url_NotValidated"
2573  }
2574  ]
2575  }
2576  ]
2577  })"},
2578  {"download_shard: many shards.",
2579  __LINE__,
2580  {
2581  "download_shard",
2582  "200000000",
2583  "url_NotValidated0",
2584  "199999999",
2585  "url_NotValidated1",
2586  "199999998",
2587  "url_NotValidated2",
2588  "199999997",
2589  "url_NotValidated3",
2590  },
2591  RPCCallTestData::no_exception,
2592  R"({
2593  "method" : "download_shard",
2594  "params" : [
2595  {
2596  "api_version" : %MAX_API_VER%,
2597  "shards" : [
2598  {
2599  "index" : 200000000,
2600  "url" : "url_NotValidated0"
2601  },
2602  {
2603  "index" : 199999999,
2604  "url" : "url_NotValidated1"
2605  },
2606  {
2607  "index" : 199999998,
2608  "url" : "url_NotValidated2"
2609  },
2610  {
2611  "index" : 199999997,
2612  "url" : "url_NotValidated3"
2613  }
2614  ]
2615  }
2616  ]
2617  })"},
2618  {"download_shard: many shards.",
2619  __LINE__,
2620  {
2621  "download_shard",
2622  "2000000",
2623  "url_NotValidated0",
2624  "2000001",
2625  "url_NotValidated1",
2626  "2000002",
2627  "url_NotValidated2",
2628  "2000003",
2629  "url_NotValidated3",
2630  "2000004",
2631  "url_NotValidated4",
2632  },
2633  RPCCallTestData::no_exception,
2634  R"({
2635  "method" : "download_shard",
2636  "params" : [
2637  {
2638  "api_version" : %MAX_API_VER%,
2639  "shards" : [
2640  {
2641  "index" : 2000000,
2642  "url" : "url_NotValidated0"
2643  },
2644  {
2645  "index" : 2000001,
2646  "url" : "url_NotValidated1"
2647  },
2648  {
2649  "index" : 2000002,
2650  "url" : "url_NotValidated2"
2651  },
2652  {
2653  "index" : 2000003,
2654  "url" : "url_NotValidated3"
2655  },
2656  {
2657  "index" : 2000004,
2658  "url" : "url_NotValidated4"
2659  }
2660  ]
2661  }
2662  ]
2663  })"},
2664  {"download_shard: too few arguments.",
2665  __LINE__,
2666  {"download_shard", "20"},
2667  RPCCallTestData::no_exception,
2668  R"({
2669  "method" : "download_shard",
2670  "params" : [
2671  {
2672  "error" : "badSyntax",
2673  "error_code" : 1,
2674  "error_message" : "Syntax error."
2675  }
2676  ]
2677  })"},
2678  {// Note: this should return an error but not throw.
2679  "download_shard: novalidate too few arguments.",
2680  __LINE__,
2681  {"download_shard", "novalidate", "20"},
2682  RPCCallTestData::bad_cast,
2683  R"()"},
2684  {"download_shard: novalidate at end.",
2685  __LINE__,
2686  {
2687  "download_shard",
2688  "20",
2689  "url_NotValidated",
2690  "novalidate",
2691  },
2692  RPCCallTestData::no_exception,
2693  R"({
2694  "method" : "download_shard",
2695  "params" : [
2696  {
2697  "api_version" : %MAX_API_VER%,
2698  "shards" : [
2699  {
2700  "index" : 20,
2701  "url" : "url_NotValidated"
2702  }
2703  ]
2704  }
2705  ]
2706  })"},
2707  {"download_shard: novalidate in middle.",
2708  __LINE__,
2709  {
2710  "download_shard",
2711  "20",
2712  "url_NotValidated20",
2713  "novalidate",
2714  "200",
2715  "url_NotValidated200",
2716  },
2717  RPCCallTestData::no_exception,
2718  R"({
2719  "method" : "download_shard",
2720  "params" : [
2721  {
2722  "error" : "invalidParams",
2723  "error_code" : 31,
2724  "error_message" : "Invalid parameters."
2725  }
2726  ]
2727  })"},
2728  {// Note: this should return an error but not throw.
2729  "download_shard: arguments swapped.",
2730  __LINE__,
2731  {
2732  "download_shard",
2733  "url_NotValidated",
2734  "20",
2735  },
2736  RPCCallTestData::bad_cast,
2737  R"()"},
2738  {"download_shard: index too small.",
2739  __LINE__,
2740  {
2741  "download_shard",
2742  "-1",
2743  "url_NotValidated",
2744  },
2745  RPCCallTestData::bad_cast,
2746  R"()"},
2747  {"download_shard: index too big.",
2748  __LINE__,
2749  {
2750  "download_shard",
2751  "4294967296",
2752  "url_NotValidated",
2753  },
2754  RPCCallTestData::bad_cast,
2755  R"()"},
2756 
2757  // feature
2758  // ---------------------------------------------------------------------
2759  {"feature: minimal.",
2760  __LINE__,
2761  {
2762  "feature",
2763  },
2764  RPCCallTestData::no_exception,
2765  R"({
2766  "method" : "feature",
2767  "params" : [
2768  {
2769  "api_version" : %MAX_API_VER%,
2770  }
2771  ]
2772  })"},
2773  {"feature: with name.",
2774  __LINE__,
2775  {"feature", "featureNameOrHexIsNotValidated"},
2776  RPCCallTestData::no_exception,
2777  R"({
2778  "method" : "feature",
2779  "params" : [
2780  {
2781  "api_version" : %MAX_API_VER%,
2782  "feature" : "featureNameOrHexIsNotValidated"
2783  }
2784  ]
2785  })"},
2786  {"feature: accept.",
2787  __LINE__,
2788  {"feature",
2789  "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA98"
2790  "76543210",
2791  "accept"},
2792  RPCCallTestData::no_exception,
2793  R"({
2794  "method" : "feature",
2795  "params" : [
2796  {
2797  "api_version" : %MAX_API_VER%,
2798  "feature" : "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
2799  "vetoed" : false
2800  }
2801  ]
2802  })"},
2803  {"feature: reject.",
2804  __LINE__,
2805  {"feature", "0", "reject"},
2806  RPCCallTestData::no_exception,
2807  R"({
2808  "method" : "feature",
2809  "params" : [
2810  {
2811  "api_version" : %MAX_API_VER%,
2812  "feature" : "0",
2813  "vetoed" : true
2814  }
2815  ]
2816  })"},
2817  {"feature: too many arguments.",
2818  __LINE__,
2819  {"feature", "featureNameOrHexIsNotValidated", "accept", "anotherArg"},
2820  RPCCallTestData::no_exception,
2821  R"({
2822  "method" : "feature",
2823  "params" : [
2824  {
2825  "error" : "badSyntax",
2826  "error_code" : 1,
2827  "error_message" : "Syntax error."
2828  }
2829  ]
2830  })"},
2831  {"feature: neither accept nor reject.",
2832  __LINE__,
2833  {
2834  "feature",
2835  "featureNameOrHexIsNotValidated",
2836  "veto",
2837  },
2838  RPCCallTestData::no_exception,
2839  R"({
2840  "method" : "feature",
2841  "params" : [
2842  {
2843  "error" : "invalidParams",
2844  "error_code" : 31,
2845  "error_message" : "Invalid parameters."
2846  }
2847  ]
2848  })"},
2849 
2850  // fetch_info
2851  // ------------------------------------------------------------------
2852  {"fetch_info: minimal.",
2853  __LINE__,
2854  {
2855  "fetch_info",
2856  },
2857  RPCCallTestData::no_exception,
2858  R"({
2859  "method" : "fetch_info",
2860  "params" : [
2861  {
2862  "api_version" : %MAX_API_VER%,
2863  }
2864  ]
2865  })"},
2866  {"fetch_info: clear.",
2867  __LINE__,
2868  {"fetch_info", "clear"},
2869  RPCCallTestData::no_exception,
2870  R"({
2871  "method" : "fetch_info",
2872  "params" : [
2873  {
2874  "api_version" : %MAX_API_VER%,
2875  "clear" : true
2876  }
2877  ]
2878  })"},
2879  {"fetch_info: too many arguments.",
2880  __LINE__,
2881  {"fetch_info", "clear", "other"},
2882  RPCCallTestData::no_exception,
2883  R"({
2884  "method" : "fetch_info",
2885  "params" : [
2886  {
2887  "error" : "badSyntax",
2888  "error_code" : 1,
2889  "error_message" : "Syntax error."
2890  }
2891  ]
2892  })"},
2893  {"fetch_info: other trailing argument.",
2894  __LINE__,
2895  {"fetch_info", "too"},
2896  RPCCallTestData::no_exception,
2897  R"({
2898  "method" : "fetch_info",
2899  "params" : [
2900  {
2901  "api_version" : %MAX_API_VER%,
2902  "too" : true
2903  }
2904  ]
2905  })"},
2906 
2907  // gateway_balances
2908  // ------------------------------------------------------------
2909  {"gateway_balances: minimal.",
2910  __LINE__,
2911  {"gateway_balances", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
2912  RPCCallTestData::no_exception,
2913  R"({
2914  "method" : "gateway_balances",
2915  "params" : [
2916  {
2917  "api_version" : %MAX_API_VER%,
2918  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2919  }
2920  ]
2921  })"},
2922  {"gateway_balances: with ledger index.",
2923  __LINE__,
2924  {"gateway_balances", "890765", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
2925  RPCCallTestData::no_exception,
2926  R"({
2927  "method" : "gateway_balances",
2928  "params" : [
2929  {
2930  "api_version" : %MAX_API_VER%,
2931  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2932  "ledger_index" : "890765"
2933  }
2934  ]
2935  })"},
2936  {"gateway_balances: with text ledger index.",
2937  __LINE__,
2938  {"gateway_balances", "current", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
2939  RPCCallTestData::no_exception,
2940  R"({
2941  "method" : "gateway_balances",
2942  "params" : [
2943  {
2944  "api_version" : %MAX_API_VER%,
2945  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2946  "ledger_index" : "current"
2947  }
2948  ]
2949  })"},
2950  {"gateway_balances: with 64 character ledger hash.",
2951  __LINE__,
2952  {"gateway_balances",
2953  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
2954  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
2955  RPCCallTestData::no_exception,
2956  R"({
2957  "method" : "gateway_balances",
2958  "params" : [
2959  {
2960  "api_version" : %MAX_API_VER%,
2961  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2962  "ledger_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
2963  }
2964  ]
2965  })"},
2966  {"gateway_balances: 1 hotwallet.",
2967  __LINE__,
2968  {"gateway_balances",
2969  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2970  "hotwallet_is_not_validated"},
2971  RPCCallTestData::no_exception,
2972  R"({
2973  "method" : "gateway_balances",
2974  "params" : [
2975  {
2976  "api_version" : %MAX_API_VER%,
2977  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2978  "hotwallet" : [ "hotwallet_is_not_validated" ]
2979  }
2980  ]
2981  })"},
2982  {"gateway_balances: 3 hotwallets.",
2983  __LINE__,
2984  {
2985  "gateway_balances",
2986  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
2987  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2988  "hotwallet_is_not_validated_1",
2989  "hotwallet_is_not_validated_2",
2990  "hotwallet_is_not_validated_3",
2991  },
2992  RPCCallTestData::no_exception,
2993  R"({
2994  "method" : "gateway_balances",
2995  "params" : [
2996  {
2997  "api_version" : %MAX_API_VER%,
2998  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
2999  "hotwallet" : [
3000  "hotwallet_is_not_validated_1",
3001  "hotwallet_is_not_validated_2",
3002  "hotwallet_is_not_validated_3"
3003  ],
3004  "ledger_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
3005  }
3006  ]
3007  })"},
3008  {"gateway_balances: too few arguments.",
3009  __LINE__,
3010  {
3011  "gateway_balances",
3012  },
3013  RPCCallTestData::no_exception,
3014  R"({
3015  "method" : "gateway_balances",
3016  "params" : [
3017  {
3018  "error" : "badSyntax",
3019  "error_code" : 1,
3020  "error_message" : "Syntax error."
3021  }
3022  ]
3023  })"},
3024  {"gateway_balances: empty first argument.",
3025  __LINE__,
3026  {"gateway_balances", ""},
3027  RPCCallTestData::no_exception,
3028  R"({
3029  "method" : "gateway_balances",
3030  "params" : [
3031  {
3032  "error" : "invalidParams",
3033  "error_code" : 31,
3034  "error_message" : "Invalid first parameter"
3035  }
3036  ]
3037  })"},
3038  {"gateway_balances: with ledger index but no gateway.",
3039  __LINE__,
3040  {
3041  "gateway_balances",
3042  "890765",
3043  },
3044  RPCCallTestData::no_exception,
3045  R"({
3046  "method" : "gateway_balances",
3047  "params" : [
3048  {
3049  "error" : "invalidParams",
3050  "error_code" : 31,
3051  "error_message" : "Invalid hotwallet"
3052  }
3053  ]
3054  })"},
3055  {"gateway_balances: with text ledger index but no gateway.",
3056  __LINE__,
3057  {
3058  "gateway_balances",
3059  "current",
3060  },
3061  RPCCallTestData::no_exception,
3062  R"({
3063  "method" : "gateway_balances",
3064  "params" : [
3065  {
3066  "error" : "invalidParams",
3067  "error_code" : 31,
3068  "error_message" : "Invalid hotwallet"
3069  }
3070  ]
3071  })"},
3072  {"gateway_balances: with 64 character ledger hash but no gateway.",
3073  __LINE__,
3074  {
3075  "gateway_balances",
3076  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
3077  },
3078  RPCCallTestData::no_exception,
3079  R"({
3080  "method" : "gateway_balances",
3081  "params" : [
3082  {
3083  "error" : "invalidParams",
3084  "error_code" : 31,
3085  "error_message" : "Invalid hotwallet"
3086  }
3087  ]
3088  })"},
3089 
3090  // get_counts
3091  // ------------------------------------------------------------------
3092  {"get_counts: minimal.",
3093  __LINE__,
3094  {
3095  "get_counts",
3096  },
3097  RPCCallTestData::no_exception,
3098  R"({
3099  "method" : "get_counts",
3100  "params" : [
3101  {
3102  "api_version" : %MAX_API_VER%,
3103  }
3104  ]
3105  })"},
3106  {"get_counts: with maximum count.",
3107  __LINE__,
3108  {"get_counts", "100"},
3109  RPCCallTestData::no_exception,
3110  R"({
3111  "method" : "get_counts",
3112  "params" : [
3113  {
3114  "api_version" : %MAX_API_VER%,
3115  "min_count" : 100
3116  }
3117  ]
3118  })"},
3119  {"get_counts: too many arguments.",
3120  __LINE__,
3121  {"get_counts", "100", "whatever"},
3122  RPCCallTestData::no_exception,
3123  R"({
3124  "method" : "get_counts",
3125  "params" : [
3126  {
3127  "error" : "badSyntax",
3128  "error_code" : 1,
3129  "error_message" : "Syntax error."
3130  }
3131  ]
3132  })"},
3133  {"get_counts: count too small.",
3134  __LINE__,
3135  {
3136  "get_counts",
3137  "-1",
3138  },
3139  RPCCallTestData::bad_cast,
3140  R"()"},
3141  {"get_counts: count too large.",
3142  __LINE__,
3143  {"get_counts", "4294967296"},
3144  RPCCallTestData::bad_cast,
3145  R"()"},
3146 
3147  // json
3148  // ------------------------------------------------------------------------
3149  {"json: minimal.",
3150  __LINE__,
3151  {
3152  "json",
3153  "command",
3154  R"({"json_argument":true})",
3155  },
3156  RPCCallTestData::no_exception,
3157  R"({
3158  "method" : "command",
3159  "params" : [
3160  {
3161  "api_version" : %MAX_API_VER%,
3162  "json_argument" : true,
3163  "method" : "command"
3164  }
3165  ]
3166  })"},
3167  {"json: null object.",
3168  __LINE__,
3169  {
3170  "json",
3171  "command",
3172  R"({})",
3173  },
3174  RPCCallTestData::no_exception,
3175  R"({
3176  "method" : "command",
3177  "params" : [
3178  {
3179  "api_version" : %MAX_API_VER%,
3180  "method" : "command"
3181  }
3182  ]
3183  })"},
3184  {"json: too few arguments.",
3185  __LINE__,
3186  {"json", "command"},
3187  RPCCallTestData::no_exception,
3188  R"({
3189  "method" : "json",
3190  "params" : [
3191  {
3192  "error" : "badSyntax",
3193  "error_code" : 1,
3194  "error_message" : "Syntax error."
3195  }
3196  ]
3197  })"},
3198  {"json: too many arguments.",
3199  __LINE__,
3200  {"json", "command", R"({"json_argument":true})", "extra"},
3201  RPCCallTestData::no_exception,
3202  R"({
3203  "method" : "json",
3204  "params" : [
3205  {
3206  "error" : "badSyntax",
3207  "error_code" : 1,
3208  "error_message" : "Syntax error."
3209  }
3210  ]
3211  })"},
3212  {"json: array, not object.",
3213  __LINE__,
3214  {
3215  "json",
3216  "command",
3217  R"(["arg1","arg2"])",
3218  },
3219  RPCCallTestData::no_exception,
3220  R"({
3221  "method" : "json",
3222  "params" : [
3223  {
3224  "error" : "invalidParams",
3225  "error_code" : 31,
3226  "error_message" : "Invalid parameters."
3227  }
3228  ]
3229  })"},
3230  {"json: invalid json (note closing comma).",
3231  __LINE__,
3232  {
3233  "json",
3234  "command",
3235  R"({"json_argument":true,})",
3236  },
3237  RPCCallTestData::no_exception,
3238  R"({
3239  "method" : "json",
3240  "params" : [
3241  {
3242  "error" : "invalidParams",
3243  "error_code" : 31,
3244  "error_message" : "Invalid parameters."
3245  }
3246  ]
3247  })"},
3248 
3249  // json2
3250  // -----------------------------------------------------------------------
3251  {"json2: minimal object.",
3252  __LINE__,
3253  {
3254  "json2",
3255  R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"})",
3256  },
3257  RPCCallTestData::no_exception,
3258  R"({
3259  "id" : "A1",
3260  "jsonrpc" : "2.0",
3261  "method" : "call_1",
3262  "params" : [
3263  {
3264  "api_version" : %MAX_API_VER%,
3265  "id" : "A1",
3266  "jsonrpc" : "2.0",
3267  "method" : "call_1",
3268  "ripplerpc" : "2.0"
3269  }
3270  ],
3271  "ripplerpc" : "2.0"
3272  })"},
3273  {"json2: object with nested params.",
3274  __LINE__,
3275  {
3276  "json2",
3277  R"({
3278  "jsonrpc" : "2.0",
3279  "ripplerpc" : "2.0",
3280  "id" : "A1",
3281  "method" : "call_1",
3282  "params" : [{"inner_arg" : "yup"}]
3283  })",
3284  },
3285  RPCCallTestData::no_exception,
3286  R"({
3287  "id" : "A1",
3288  "jsonrpc" : "2.0",
3289  "method" : "call_1",
3290  "params" : [
3291  {
3292  "api_version" : %MAX_API_VER%,
3293  "0" : {
3294  "inner_arg" : "yup"
3295  },
3296  "id" : "A1",
3297  "jsonrpc" : "2.0",
3298  "method" : "call_1",
3299  "ripplerpc" : "2.0"
3300  }
3301  ],
3302  "ripplerpc" : "2.0"
3303  })"},
3304  {"json2: minimal array.",
3305  __LINE__,
3306  {
3307  "json2",
3308  R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"}])",
3309  },
3310  RPCCallTestData::no_exception,
3311  R"({
3312  "method" : "json2",
3313  "params" : [
3314  [
3315  {
3316  "api_version" : %MAX_API_VER%,
3317  "id" : "A1",
3318  "jsonrpc" : "2.0",
3319  "method" : "call_1",
3320  "ripplerpc" : "2.0"
3321  }
3322  ]
3323  ]
3324  })"},
3325  {"json2: array with object with nested params.",
3326  __LINE__,
3327  {
3328  "json2",
3329  R"([
3330  {"jsonrpc":"2.0",
3331  "ripplerpc":"2.0",
3332  "id":"A1",
3333  "method":"call_1",
3334  "params" : [{"inner_arg" : "yup"}]}
3335  ])",
3336  },
3337  RPCCallTestData::no_exception,
3338  R"({
3339  "method" : "json2",
3340  "params" : [
3341  [
3342  {
3343  "api_version" : %MAX_API_VER%,
3344  "0" : {
3345  "inner_arg" : "yup"
3346  },
3347  "id" : "A1",
3348  "jsonrpc" : "2.0",
3349  "method" : "call_1",
3350  "ripplerpc" : "2.0"
3351  }
3352  ]
3353  ]})"},
3354  {"json2: too few arguments.",
3355  __LINE__,
3356  {
3357  "json2",
3358  },
3359  RPCCallTestData::no_exception,
3360  R"({
3361  "method" : "json2",
3362  "params" : [
3363  {
3364  "error" : "badSyntax",
3365  "error_code" : 1,
3366  "error_message" : "Syntax error."
3367  }
3368  ]
3369  })"},
3370  {"json2: too many arguments.",
3371  __LINE__,
3372  {"json2",
3373  R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_this"})",
3374  "extra"},
3375  RPCCallTestData::no_exception,
3376  R"({
3377  "method" : "json2",
3378  "params" : [
3379  {
3380  "error" : "badSyntax",
3381  "error_code" : 1,
3382  "error_message" : "Syntax error."
3383  }
3384  ]
3385  })"},
3386  {"json2: malformed json (note extra comma).",
3387  __LINE__,
3388  {
3389  "json2",
3390  R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",})",
3391  },
3392  RPCCallTestData::no_exception,
3393  R"({
3394  "id" : "A1",
3395  "jsonrpc" : "2.0",
3396  "method" : "json2",
3397  "params" : [
3398  {
3399  "error" : "invalidParams",
3400  "error_code" : 31,
3401  "error_message" : "Invalid parameters.",
3402  "id" : "A1",
3403  "jsonrpc" : "2.0",
3404  "ripplerpc" : "2.0"
3405  }
3406  ],
3407  "ripplerpc" : "2.0"
3408  })"},
3409  {"json2: omit jsonrpc.",
3410  __LINE__,
3411  {
3412  "json2",
3413  R"({"ripplerpc":"2.0","id":"A1","method":"call_1"})",
3414  },
3415  RPCCallTestData::no_exception,
3416  R"({
3417  "id" : "A1",
3418  "method" : "json2",
3419  "params" : [
3420  {
3421  "error" : "invalidParams",
3422  "error_code" : 31,
3423  "error_message" : "Invalid parameters.",
3424  "id" : "A1",
3425  "ripplerpc" : "2.0"
3426  }
3427  ],
3428  "ripplerpc" : "2.0"
3429  })"},
3430  {"json2: wrong jsonrpc version.",
3431  __LINE__,
3432  {
3433  "json2",
3434  R"({"jsonrpc":"2.1","ripplerpc":"2.0","id":"A1","method":"call_1"})",
3435  },
3436  RPCCallTestData::no_exception,
3437  R"({
3438  "id" : "A1",
3439  "jsonrpc" : "2.1",
3440  "method" : "json2",
3441  "params" : [
3442  {
3443  "error" : "invalidParams",
3444  "error_code" : 31,
3445  "error_message" : "Invalid parameters.",
3446  "id" : "A1",
3447  "jsonrpc" : "2.1",
3448  "ripplerpc" : "2.0"
3449  }
3450  ],
3451  "ripplerpc" : "2.0"
3452  })"},
3453  {"json2: omit ripplerpc.",
3454  __LINE__,
3455  {
3456  "json2",
3457  R"({"jsonrpc":"2.0","id":"A1","method":"call_1"})",
3458  },
3459  RPCCallTestData::no_exception,
3460  R"({
3461  "id" : "A1",
3462  "jsonrpc" : "2.0",
3463  "method" : "json2",
3464  "params" : [
3465  {
3466  "error" : "invalidParams",
3467  "error_code" : 31,
3468  "error_message" : "Invalid parameters.",
3469  "id" : "A1",
3470  "jsonrpc" : "2.0"
3471  }
3472  ]
3473  })"},
3474  {"json2: wrong ripplerpc version.",
3475  __LINE__,
3476  {
3477  "json2",
3478  R"({"jsonrpc":"2.0","ripplerpc":"2.00","id":"A1","method":"call_1"})",
3479  },
3480  RPCCallTestData::no_exception,
3481  R"({
3482  "id" : "A1",
3483  "jsonrpc" : "2.0",
3484  "method" : "json2",
3485  "params" : [
3486  {
3487  "error" : "invalidParams",
3488  "error_code" : 31,
3489  "error_message" : "Invalid parameters.",
3490  "id" : "A1",
3491  "jsonrpc" : "2.0",
3492  "ripplerpc" : "2.00"
3493  }
3494  ],
3495  "ripplerpc" : "2.00"
3496  })"},
3497  {"json2: omit id.",
3498  __LINE__,
3499  {
3500  "json2",
3501  R"({"jsonrpc":"2.0","ripplerpc":"2.0","method":"call_1"})",
3502  },
3503  RPCCallTestData::no_exception,
3504  R"({
3505  "jsonrpc" : "2.0",
3506  "method" : "json2",
3507  "params" : [
3508  {
3509  "error" : "invalidParams",
3510  "error_code" : 31,
3511  "error_message" : "Invalid parameters.",
3512  "jsonrpc" : "2.0",
3513  "ripplerpc" : "2.0"
3514  }
3515  ],
3516  "ripplerpc" : "2.0"
3517  })"},
3518  {"json2: omit method.",
3519  __LINE__,
3520  {
3521  "json2",
3522  R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1"})",
3523  },
3524  RPCCallTestData::no_exception,
3525  R"({
3526  "id" : "A1",
3527  "jsonrpc" : "2.0",
3528  "method" : "json2",
3529  "params" : [
3530  {
3531  "error" : "invalidParams",
3532  "error_code" : 31,
3533  "error_message" : "Invalid parameters.",
3534  "id" : "A1",
3535  "jsonrpc" : "2.0",
3536  "ripplerpc" : "2.0"
3537  }
3538  ],
3539  "ripplerpc" : "2.0"
3540  })"},
3541  {"json2: empty outer array.",
3542  __LINE__,
3543  {
3544  "json2",
3545  R"([])",
3546  },
3547  RPCCallTestData::no_exception,
3548  R"({
3549  "method" : "json2",
3550  "params" : [
3551  {
3552  "error" : "invalidParams",
3553  "error_code" : 31,
3554  "error_message" : "Invalid parameters."
3555  }
3556  ]
3557  })"},
3558  {"json2: empty inner array.",
3559  __LINE__,
3560  {
3561  "json2",
3562  R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",[]}])",
3563  },
3564  RPCCallTestData::no_exception,
3565  R"({
3566  "method" : "json2",
3567  "params" : [
3568  {
3569  "error" : "invalidParams",
3570  "error_code" : 31,
3571  "error_message" : "Invalid parameters."
3572  }
3573  ]
3574  })"},
3575  {"json2: array with non-json2 object.",
3576  __LINE__,
3577  {
3578  "json2",
3579  R"([
3580  {"jsonrpc" : "2.1",
3581  "ripplerpc" : "2.0",
3582  "id" : "A1",
3583  "method" : "call_1"
3584  }
3585  ])",
3586  },
3587  RPCCallTestData::no_exception,
3588  R"({
3589  "method" : "json2",
3590  "params" : [
3591  {
3592  "error" : "invalidParams",
3593  "error_code" : 31,
3594  "error_message" : "Invalid parameters."
3595  }
3596  ]
3597  })"},
3598  {"json2: non-object or -array inner params member.",
3599  __LINE__,
3600  {
3601  "json2",
3602  R"({
3603  "jsonrpc" : "2.0",
3604  "ripplerpc" : "2.0",
3605  "id" : "A1",
3606  "method" : "call_1",
3607  "params" : true
3608  })",
3609  },
3610  RPCCallTestData::no_exception,
3611  R"({
3612  "id" : "A1",
3613  "jsonrpc" : "2.0",
3614  "method" : "json2",
3615  "params" : [
3616  {
3617  "error" : "invalidParams",
3618  "error_code" : 31,
3619  "error_message" : "Invalid parameters.",
3620  "id" : "A1",
3621  "jsonrpc" : "2.0",
3622  "ripplerpc" : "2.0"
3623  }
3624  ],
3625  "ripplerpc" : "2.0"
3626  })"},
3627 
3628  // ledger
3629  // ----------------------------------------------------------------------
3630  {"ledger: minimal.",
3631  __LINE__,
3632  {"ledger"},
3633  RPCCallTestData::no_exception,
3634  R"({
3635  "method" : "ledger",
3636  "params" : [
3637  {
3638  "api_version" : %MAX_API_VER%,
3639  }
3640  ]
3641  })"},
3642  {"ledger: ledger index.",
3643  __LINE__,
3644  {"ledger", "4294967295"},
3645  RPCCallTestData::no_exception,
3646  R"({
3647  "method" : "ledger",
3648  "params" : [
3649  {
3650  "api_version" : %MAX_API_VER%,
3651  "ledger_index" : 4294967295
3652  }
3653  ]
3654  })"},
3655  {"ledger: text ledger index.",
3656  __LINE__,
3657  {"ledger", "validated"},
3658  RPCCallTestData::no_exception,
3659  R"({
3660  "method" : "ledger",
3661  "params" : [
3662  {
3663  "api_version" : %MAX_API_VER%,
3664  "ledger_index" : "validated"
3665  }
3666  ]
3667  })"},
3668  {"ledger: ledger hash.",
3669  __LINE__,
3670  {"ledger",
3671  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
3672  RPCCallTestData::no_exception,
3673  R"({
3674  "method" : "ledger",
3675  "params" : [
3676  {
3677  "api_version" : %MAX_API_VER%,
3678  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
3679  }
3680  ]
3681  })"},
3682  {"ledger: full.",
3683  __LINE__,
3684  {"ledger", "current", "full"},
3685  RPCCallTestData::no_exception,
3686  R"({
3687  "method" : "ledger",
3688  "params" : [
3689  {
3690  "api_version" : %MAX_API_VER%,
3691  "full" : true,
3692  "ledger_index" : "current"
3693  }
3694  ]
3695  })"},
3696  {"ledger: tx.",
3697  __LINE__,
3698  {"ledger", "closed", "tx"},
3699  RPCCallTestData::no_exception,
3700  R"({
3701  "method" : "ledger",
3702  "params" : [
3703  {
3704  "api_version" : %MAX_API_VER%,
3705  "expand" : true,
3706  "ledger_index" : "closed",
3707  "transactions" : true
3708  }
3709  ]
3710  })"},
3711  {"ledger: too many arguments.",
3712  __LINE__,
3713  {"ledger", "4294967295", "spare"},
3714  RPCCallTestData::no_exception,
3715  R"({
3716  "method" : "ledger",
3717  "params" : [
3718  {
3719  "api_version" : %MAX_API_VER%,
3720  "ledger_index" : 4294967295
3721  }
3722  ]
3723  })"},
3724  {"ledger: ledger index too small.",
3725  __LINE__,
3726  {"ledger", "-1"},
3727  RPCCallTestData::no_exception,
3728  R"({
3729  "method" : "ledger",
3730  "params" : [
3731  {
3732  "api_version" : %MAX_API_VER%,
3733  "ledger_index" : 0
3734  }
3735  ]
3736  })"},
3737  {"ledger: ledger index too big.",
3738  __LINE__,
3739  {"ledger", "4294967296"},
3740  RPCCallTestData::no_exception,
3741  R"({
3742  "method" : "ledger",
3743  "params" : [
3744  {
3745  "api_version" : %MAX_API_VER%,
3746  "ledger_index" : 0
3747  }
3748  ]
3749  })"},
3750  {"ledger: invalid ledger text.",
3751  __LINE__,
3752  {"ledger", "latest"},
3753  RPCCallTestData::no_exception,
3754  R"({
3755  "method" : "ledger",
3756  "params" : [
3757  {
3758  "api_version" : %MAX_API_VER%,
3759  "ledger_index" : 0
3760  }
3761  ]
3762  })"},
3763  {"ledger: unsupported final argument.",
3764  __LINE__,
3765  {"ledger", "current", "expand"},
3766  RPCCallTestData::no_exception,
3767  R"({
3768  "method" : "ledger",
3769  "params" : [
3770  {
3771  "api_version" : %MAX_API_VER%,
3772  "ledger_index" : "current"
3773  }
3774  ]
3775  })"},
3776 
3777  // ledger_closed
3778  // ---------------------------------------------------------------
3779  {"ledger_closed: minimal.",
3780  __LINE__,
3781  {"ledger_closed"},
3782  RPCCallTestData::no_exception,
3783  R"({
3784  "method" : "ledger_closed",
3785  "params" : [
3786  {
3787  "api_version" : %MAX_API_VER%,
3788  }
3789  ]
3790  })"},
3791  {"ledger_closed: too many arguments.",
3792  __LINE__,
3793  {"ledger_closed", "today"},
3794  RPCCallTestData::no_exception,
3795  R"({
3796  "method" : "ledger_closed",
3797  "params" : [
3798  {
3799  "error" : "badSyntax",
3800  "error_code" : 1,
3801  "error_message" : "Syntax error."
3802  }
3803  ]
3804  })"},
3805 
3806  // ledger_current
3807  // --------------------------------------------------------------
3808  {"ledger_current: minimal.",
3809  __LINE__,
3810  {"ledger_current"},
3811  RPCCallTestData::no_exception,
3812  R"({
3813  "method" : "ledger_current",
3814  "params" : [
3815  {
3816  "api_version" : %MAX_API_VER%,
3817  }
3818  ]
3819  })"},
3820  {"ledger_current: too many arguments.",
3821  __LINE__,
3822  {"ledger_current", "today"},
3823  RPCCallTestData::no_exception,
3824  R"({
3825  "method" : "ledger_current",
3826  "params" : [
3827  {
3828  "error" : "badSyntax",
3829  "error_code" : 1,
3830  "error_message" : "Syntax error."
3831  }
3832  ]
3833  })"},
3834 
3835  // ledger_header
3836  // ---------------------------------------------------------------
3837  {"ledger_header: ledger index.",
3838  __LINE__,
3839  {"ledger_header", "4294967295"},
3840  RPCCallTestData::no_exception,
3841  R"({
3842  "method" : "ledger_header",
3843  "params" : [
3844  {
3845  "api_version" : %MAX_API_VER%,
3846  "ledger_index" : 4294967295
3847  }
3848  ]
3849  })"},
3850  {"ledger_header: ledger hash.",
3851  __LINE__,
3852  {"ledger_header",
3853  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
3854  RPCCallTestData::no_exception,
3855  R"({
3856  "method" : "ledger_header",
3857  "params" : [
3858  {
3859  "api_version" : %MAX_API_VER%,
3860  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
3861  }
3862  ]
3863  })"},
3864  {"ledger_header: too few arguments.",
3865  __LINE__,
3866  {
3867  "ledger_header",
3868  },
3869  RPCCallTestData::no_exception,
3870  R"({
3871  "method" : "ledger_header",
3872  "params" : [
3873  {
3874  "error" : "badSyntax",
3875  "error_code" : 1,
3876  "error_message" : "Syntax error."
3877  }
3878  ]
3879  })"},
3880  {"ledger_header: too many arguments.",
3881  __LINE__,
3882  {"ledger_header", "4294967295", "spare"},
3883  RPCCallTestData::no_exception,
3884  R"({
3885  "method" : "ledger_header",
3886  "params" : [
3887  {
3888  "error" : "badSyntax",
3889  "error_code" : 1,
3890  "error_message" : "Syntax error."
3891  }
3892  ]
3893  })"},
3894  {"ledger_header: text ledger index.",
3895  __LINE__,
3896  {"ledger_header", "current"},
3897  RPCCallTestData::no_exception,
3898  R"({
3899  "method" : "ledger_header",
3900  "params" : [
3901  {
3902  "api_version" : %MAX_API_VER%,
3903  "ledger_index" : 0
3904  }
3905  ]
3906  })"},
3907  {"ledger_header: ledger index too small.",
3908  __LINE__,
3909  {"ledger_header", "-1"},
3910  RPCCallTestData::no_exception,
3911  R"({
3912  "method" : "ledger_header",
3913  "params" : [
3914  {
3915  "api_version" : %MAX_API_VER%,
3916  "ledger_index" : 0
3917  }
3918  ]
3919  })"},
3920  {"ledger_header: ledger index too big.",
3921  __LINE__,
3922  {"ledger_header", "4294967296"},
3923  RPCCallTestData::no_exception,
3924  R"({
3925  "method" : "ledger_header",
3926  "params" : [
3927  {
3928  "api_version" : %MAX_API_VER%,
3929  "ledger_index" : 0
3930  }
3931  ]
3932  })"},
3933 
3934  // ledger_request
3935  // --------------------------------------------------------------
3936  {"ledger_request: ledger index.",
3937  __LINE__,
3938  {"ledger_request", "4294967295"},
3939  RPCCallTestData::no_exception,
3940  R"({
3941  "method" : "ledger_request",
3942  "params" : [
3943  {
3944  "api_version" : %MAX_API_VER%,
3945  "ledger_index" : 4294967295
3946  }
3947  ]
3948  })"},
3949  {"ledger_request: ledger hash.",
3950  __LINE__,
3951  {"ledger_request",
3952  "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"},
3953  RPCCallTestData::no_exception,
3954  R"({
3955  "method" : "ledger_request",
3956  "params" : [
3957  {
3958  "api_version" : %MAX_API_VER%,
3959  "ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
3960  }
3961  ]
3962  })"},
3963  {"ledger_request: too few arguments.",
3964  __LINE__,
3965  {
3966  "ledger_request",
3967  },
3968  RPCCallTestData::no_exception,
3969  R"({
3970  "method" : "ledger_request",
3971  "params" : [
3972  {
3973  "error" : "badSyntax",
3974  "error_code" : 1,
3975  "error_message" : "Syntax error."
3976  }
3977  ]
3978  })"},
3979  {"ledger_request: too many arguments.",
3980  __LINE__,
3981  {"ledger_request", "4294967295", "spare"},
3982  RPCCallTestData::no_exception,
3983  R"({
3984  "method" : "ledger_request",
3985  "params" : [
3986  {
3987  "error" : "badSyntax",
3988  "error_code" : 1,
3989  "error_message" : "Syntax error."
3990  }
3991  ]
3992  })"},
3993  {"ledger_request: text ledger index.",
3994  __LINE__,
3995  {"ledger_request", "current"},
3996  RPCCallTestData::no_exception,
3997  R"({
3998  "method" : "ledger_request",
3999  "params" : [
4000  {
4001  "api_version" : %MAX_API_VER%,
4002  "ledger_index" : 0
4003  }
4004  ]
4005  })"},
4006  {"ledger_request: ledger index too small.",
4007  __LINE__,
4008  {"ledger_request", "-1"},
4009  RPCCallTestData::no_exception,
4010  R"({
4011  "method" : "ledger_request",
4012  "params" : [
4013  {
4014  "api_version" : %MAX_API_VER%,
4015  "ledger_index" : 0
4016  }
4017  ]
4018  })"},
4019  {"ledger_request: ledger index too big.",
4020  __LINE__,
4021  {"ledger_request", "4294967296"},
4022  RPCCallTestData::no_exception,
4023  R"({
4024  "method" : "ledger_request",
4025  "params" : [
4026  {
4027  "api_version" : %MAX_API_VER%,
4028  "ledger_index" : 0
4029  }
4030  ]
4031  })"},
4032 
4033  // log_level
4034  // -------------------------------------------------------------------
4035  {"log_level: minimal.",
4036  __LINE__,
4037  {
4038  "log_level",
4039  },
4040  RPCCallTestData::no_exception,
4041  R"({
4042  "method" : "log_level",
4043  "params" : [
4044  {
4045  "api_version" : %MAX_API_VER%,
4046  }
4047  ]
4048  })"},
4049  {"log_level: fatal.",
4050  __LINE__,
4051  {"log_level", "fatal"},
4052  RPCCallTestData::no_exception,
4053  R"({
4054  "method" : "log_level",
4055  "params" : [
4056  {
4057  "api_version" : %MAX_API_VER%,
4058  "severity" : "fatal"
4059  }
4060  ]
4061  })"},
4062  {"log_level: error.",
4063  __LINE__,
4064  {"log_level", "error"},
4065  RPCCallTestData::no_exception,
4066  R"({
4067  "method" : "log_level",
4068  "params" : [
4069  {
4070  "api_version" : %MAX_API_VER%,
4071  "severity" : "error"
4072  }
4073  ]
4074  })"},
4075  {"log_level: warn.",
4076  __LINE__,
4077  {"log_level", "warn"},
4078  RPCCallTestData::no_exception,
4079  R"({
4080  "method" : "log_level",
4081  "params" : [
4082  {
4083  "api_version" : %MAX_API_VER%,
4084  "severity" : "warn"
4085  }
4086  ]
4087  })"},
4088  {"log_level: debug.",
4089  __LINE__,
4090  {"log_level", "debug"},
4091  RPCCallTestData::no_exception,
4092  R"({
4093  "method" : "log_level",
4094  "params" : [
4095  {
4096  "api_version" : %MAX_API_VER%,
4097  "severity" : "debug"
4098  }
4099  ]
4100  })"},
4101  {"log_level: trace.",
4102  __LINE__,
4103  {"log_level", "trace"},
4104  RPCCallTestData::no_exception,
4105  R"({
4106  "method" : "log_level",
4107  "params" : [
4108  {
4109  "api_version" : %MAX_API_VER%,
4110  "severity" : "trace"
4111  }
4112  ]
4113  })"},
4114  {"log_level: base partition.",
4115  __LINE__,
4116  {"log_level", "base", "trace"},
4117  RPCCallTestData::no_exception,
4118  R"({
4119  "method" : "log_level",
4120  "params" : [
4121  {
4122  "api_version" : %MAX_API_VER%,
4123  "partition" : "base",
4124  "severity" : "trace"
4125  }
4126  ]
4127  })"},
4128  {"log_level: partiton_name.",
4129  __LINE__,
4130  {"log_level", "partition_name", "fatal"},
4131  RPCCallTestData::no_exception,
4132  R"({
4133  "method" : "log_level",
4134  "params" : [
4135  {
4136  "api_version" : %MAX_API_VER%,
4137  "partition" : "partition_name",
4138  "severity" : "fatal"
4139  }
4140  ]
4141  })"},
4142  {"log_level: too many arguments.",
4143  __LINE__,
4144  {"log_level", "partition_name", "fatal", "extra"},
4145  RPCCallTestData::no_exception,
4146  R"({
4147  "method" : "log_level",
4148  "params" : [
4149  {
4150  "error" : "badSyntax",
4151  "error_code" : 1,
4152  "error_message" : "Syntax error."
4153  }
4154  ]
4155  })"},
4156  {"log_level: invalid severity.",
4157  __LINE__,
4158  {"log_level", "err"},
4159  RPCCallTestData::no_exception,
4160  R"({
4161  "method" : "log_level",
4162  "params" : [
4163  {
4164  "api_version" : %MAX_API_VER%,
4165  "severity" : "err"
4166  }
4167  ]
4168  })"},
4169  {"log_level: swap partition name and severity.",
4170  __LINE__,
4171  {
4172  "log_level",
4173  "fatal",
4174  "partition_name",
4175  },
4176  RPCCallTestData::no_exception,
4177  R"({
4178  "method" : "log_level",
4179  "params" : [
4180  {
4181  "api_version" : %MAX_API_VER%,
4182  "partition" : "fatal",
4183  "severity" : "partition_name"
4184  }
4185  ]
4186  })"},
4187 
4188  // logrotate
4189  // -------------------------------------------------------------------
4190  {"logrotate: minimal.",
4191  __LINE__,
4192  {
4193  "logrotate",
4194  },
4195  RPCCallTestData::no_exception,
4196  R"({
4197  "method" : "logrotate",
4198  "params" : [
4199  {
4200  "api_version" : %MAX_API_VER%,
4201  }
4202  ]
4203  })"},
4204  {"logrotate: too many arguments.",
4205  __LINE__,
4206  {"logrotate", "extra"},
4207  RPCCallTestData::no_exception,
4208  R"({
4209  "method" : "logrotate",
4210  "params" : [
4211  {
4212  "error" : "badSyntax",
4213  "error_code" : 1,
4214  "error_message" : "Syntax error."
4215  }
4216  ]
4217  })"},
4218 
4219  // node_to_shard
4220  // -------------------------------------------------------------------
4221  {"node_to_shard: status.",
4222  __LINE__,
4223  {"node_to_shard", "status"},
4224  RPCCallTestData::no_exception,
4225  R"({
4226  "method" : "node_to_shard",
4227  "params" : [
4228  {
4229  "api_version" : %MAX_API_VER%,
4230  "action" : "status"
4231  }
4232  ]
4233  })"},
4234  {"node_to_shard: start.",
4235  __LINE__,
4236  {"node_to_shard", "start"},
4237  RPCCallTestData::no_exception,
4238  R"({
4239  "method" : "node_to_shard",
4240  "params" : [
4241  {
4242  "api_version" : %MAX_API_VER%,
4243  "action" : "start"
4244  }
4245  ]
4246  })"},
4247  {"node_to_shard: stop.",
4248  __LINE__,
4249  {"node_to_shard", "stop"},
4250  RPCCallTestData::no_exception,
4251  R"({
4252  "method" : "node_to_shard",
4253  "params" : [
4254  {
4255  "api_version" : %MAX_API_VER%,
4256  "action" : "stop"
4257  }
4258  ]
4259  })"},
4260  {"node_to_shard: too many arguments.",
4261  __LINE__,
4262  {"node_to_shard", "start", "stop"},
4263  RPCCallTestData::no_exception,
4264  R"({
4265  "method" : "node_to_shard",
4266  "params" : [
4267  {
4268  "error" : "badSyntax",
4269  "error_code" : 1,
4270  "error_message" : "Syntax error."
4271  }
4272  ]
4273  })"},
4274  {"node_to_shard: invalid argument.",
4275  __LINE__,
4276  {"node_to_shard", "invalid"},
4277  RPCCallTestData::no_exception,
4278  R"({
4279  "method" : "node_to_shard",
4280  "params" : [
4281  {
4282  "api_version" : %MAX_API_VER%,
4283  "action" : "invalid"
4284  }
4285  ]
4286  })"},
4287 
4288  // owner_info
4289  // ------------------------------------------------------------------
4290  {"owner_info: minimal.",
4291  __LINE__,
4292  {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
4293  RPCCallTestData::no_exception,
4294  R"({
4295  "method" : "owner_info",
4296  "params" : [
4297  {
4298  "api_version" : %MAX_API_VER%,
4299  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
4300  }
4301  ]
4302  })"},
4303  {"owner_info: with numeric ledger index.",
4304  __LINE__,
4305  {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "987654321"},
4306  RPCCallTestData::no_exception,
4307  R"({
4308  "method" : "owner_info",
4309  "params" : [
4310  {
4311  "api_version" : %MAX_API_VER%,
4312  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4313  "ledger_index" : 987654321
4314  }
4315  ]
4316  })"},
4317  {"owner_info: with text ledger index.",
4318  __LINE__,
4319  {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
4320  RPCCallTestData::no_exception,
4321  R"({
4322  "method" : "owner_info",
4323  "params" : [
4324  {
4325  "api_version" : %MAX_API_VER%,
4326  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4327  "ledger_index" : "validated"
4328  }
4329  ]
4330  })"},
4331  {"owner_info: with ledger hash.",
4332  __LINE__,
4333  {"owner_info",
4334  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4335  "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"},
4336  RPCCallTestData::no_exception,
4337  R"({
4338  "method" : "owner_info",
4339  "params" : [
4340  {
4341  "api_version" : %MAX_API_VER%,
4342  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4343  "ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
4344  }
4345  ]
4346  })"},
4347  {"owner_info: with ledger index.",
4348  __LINE__,
4349  {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "validated"},
4350  RPCCallTestData::no_exception,
4351  R"({
4352  "method" : "owner_info",
4353  "params" : [
4354  {
4355  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4356  "api_version" : %MAX_API_VER%,
4357  "ledger_index" : "validated"
4358  }
4359  ]
4360  })"},
4361  {"owner_info: too few arguments.",
4362  __LINE__,
4363  {
4364  "owner_info",
4365  },
4366  RPCCallTestData::no_exception,
4367  R"({
4368  "method" : "owner_info",
4369  "params" : [
4370  {
4371  "error" : "badSyntax",
4372  "error_code" : 1,
4373  "error_message" : "Syntax error."
4374  }
4375  ]
4376  })"},
4377  {"owner_info: too many arguments.",
4378  __LINE__,
4379  {
4380  "owner_info",
4381  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4382  "current",
4383  "extra1",
4384  "extra2",
4385  },
4386  RPCCallTestData::no_exception,
4387  R"({
4388  "method" : "owner_info",
4389  "params" : [
4390  {
4391  "error" : "badSyntax",
4392  "error_code" : 1,
4393  "error_message" : "Syntax error."
4394  }
4395  ]
4396  })"},
4397  {
4398  "owner_info: invalid accountID.",
4399  __LINE__,
4400  {
4401  "owner_info",
4402  "", // Note: very few values are detected as bad!
4403  },
4404  RPCCallTestData::no_exception,
4405  R"({
4406  "method" : "owner_info",
4407  "params" : [
4408  {
4409  "error" : "actMalformed",
4410  "error_code" : 35,
4411  "error_message" : "Account malformed."
4412  }
4413  ]
4414  })",
4415  },
4416  {
4417  // Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
4418  // cannot currently occur because jvParseLedger() always returns true.
4419  "owner_info: invalid ledger selection.",
4420  __LINE__,
4421  {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
4422  RPCCallTestData::no_exception,
4423  R"({
4424  "method" : "owner_info",
4425  "params" : [
4426  {
4427  "api_version" : %MAX_API_VER%,
4428  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4429  "ledger_index" : 0
4430  }
4431  ]
4432  })",
4433  },
4434  {
4435  // Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
4436  // cannot currently occur because jvParseLedger() always returns true.
4437  "owner_info: invalid ledger selection.",
4438  __LINE__,
4439  {"owner_info", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "no_ledger"},
4440  RPCCallTestData::no_exception,
4441  R"({
4442  "method" : "owner_info",
4443  "params" : [
4444  {
4445  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4446  "api_version" : %MAX_API_VER%,
4447  "ledger_index" : 0
4448  }
4449  ]
4450  })",
4451  },
4452 
4453  // peers
4454  // -----------------------------------------------------------------------
4455  {"peers: minimal.",
4456  __LINE__,
4457  {
4458  "peers",
4459  },
4460  RPCCallTestData::no_exception,
4461  R"({
4462  "method" : "peers",
4463  "params" : [
4464  {
4465  "api_version" : %MAX_API_VER%,
4466  }
4467  ]
4468  })"},
4469  {"peers: too many arguments.",
4470  __LINE__,
4471  {"peers", "extra"},
4472  RPCCallTestData::no_exception,
4473  R"({
4474  "method" : "peers",
4475  "params" : [
4476  {
4477  "error" : "badSyntax",
4478  "error_code" : 1,
4479  "error_message" : "Syntax error."
4480  }
4481  ]
4482  })"},
4483 
4484  // peer_reservations_add
4485  // -------------------------------------------------------
4486  {"peer_reservations_add: minimal.",
4487  __LINE__,
4488  {"peer_reservations_add", "public_key_string"},
4489  RPCCallTestData::no_exception,
4490  R"({
4491  "method" : "peer_reservations_add",
4492  "params" : [
4493  {
4494  "api_version" : %MAX_API_VER%,
4495  "public_key" : "public_key_string"
4496  }
4497  ]
4498  })"},
4499  {"peer_reservations_add: with description.",
4500  __LINE__,
4501  {"peer_reservations_add", "public_key_string", "public_key_description"},
4502  RPCCallTestData::no_exception,
4503  R"({
4504  "method" : "peer_reservations_add",
4505  "params" : [
4506  {
4507  "api_version" : %MAX_API_VER%,
4508  "description" : "public_key_description",
4509  "public_key" : "public_key_string"
4510  }
4511  ]
4512  })"},
4513  {"peer_reservations_add: too few arguments.",
4514  __LINE__,
4515  {"peer_reservations_add"},
4516  RPCCallTestData::no_exception,
4517  R"({
4518  "method" : "peer_reservations_add",
4519  "params" : [
4520  {
4521  "error" : "badSyntax",
4522  "error_code" : 1,
4523  "error_message" : "Syntax error."
4524  }
4525  ]
4526  })"},
4527  {"peer_reservations_add: too many arguments.",
4528  __LINE__,
4529  {"peer_reservations_add",
4530  "public_key_string",
4531  "public_key_description",
4532  "spare"},
4533  RPCCallTestData::no_exception,
4534  R"({
4535  "method" : "peer_reservations_add",
4536  "params" : [
4537  {
4538  "error" : "badSyntax",
4539  "error_code" : 1,
4540  "error_message" : "Syntax error."
4541  }
4542  ]
4543  })"},
4544 
4545  // peer_reservations_del
4546  // -------------------------------------------------------
4547  {"peer_reservations_del: minimal.",
4548  __LINE__,
4549  {"peer_reservations_del", "public_key_string"},
4550  RPCCallTestData::no_exception,
4551  R"({
4552  "method" : "peer_reservations_del",
4553  "params" : [
4554  {
4555  "api_version" : %MAX_API_VER%,
4556  "public_key" : "public_key_string"
4557  }
4558  ]
4559  })"},
4560  {"peer_reservations_del: too few arguments.",
4561  __LINE__,
4562  {"peer_reservations_del"},
4563  RPCCallTestData::no_exception,
4564  R"({
4565  "method" : "peer_reservations_del",
4566  "params" : [
4567  {
4568  "error" : "badSyntax",
4569  "error_code" : 1,
4570  "error_message" : "Syntax error."
4571  }
4572  ]
4573  })"},
4574  {"peer_reservations_del: too many arguments.",
4575  __LINE__,
4576  {"peer_reservations_del",
4577  "public_key_string",
4578  "public_key_description",
4579  "spare"},
4580  RPCCallTestData::no_exception,
4581  R"({
4582  "method" : "peer_reservations_del",
4583  "params" : [
4584  {
4585  "error" : "badSyntax",
4586  "error_code" : 1,
4587  "error_message" : "Syntax error."
4588  }
4589  ]
4590  })"},
4591 
4592  // ping
4593  // ------------------------------------------------------------------------
4594  {"ping: minimal.",
4595  __LINE__,
4596  {
4597  "ping",
4598  },
4599  RPCCallTestData::no_exception,
4600  R"({
4601  "method" : "ping",
4602  "params" : [
4603  {
4604  "api_version" : %MAX_API_VER%,
4605  }
4606  ]
4607  })"},
4608  {"ping: too many arguments.",
4609  __LINE__,
4610  {"ping", "extra"},
4611  RPCCallTestData::no_exception,
4612  R"({
4613  "method" : "ping",
4614  "params" : [
4615  {
4616  "error" : "badSyntax",
4617  "error_code" : 1,
4618  "error_message" : "Syntax error."
4619  }
4620  ]
4621  })"},
4622 
4623  // print
4624  // -----------------------------------------------------------------------
4625  {"print: minimal.",
4626  __LINE__,
4627  {
4628  "print",
4629  },
4630  RPCCallTestData::no_exception,
4631  R"({
4632  "method" : "print",
4633  "params" : [
4634  {
4635  "api_version" : %MAX_API_VER%,
4636  }
4637  ]
4638  })"},
4639  {// The docs indicate that no arguments are allowed. So should this error?
4640  "print: extra argument.",
4641  __LINE__,
4642  {"print", "extra"},
4643  RPCCallTestData::no_exception,
4644  R"({
4645  "method" : "print",
4646  "params" : [
4647  {
4648  "api_version" : %MAX_API_VER%,
4649  "params" : [ "extra" ]
4650  }
4651  ]
4652  })"},
4653  {"print: too many arguments.",
4654  __LINE__,
4655  {"print", "extra1", "extra2"},
4656  RPCCallTestData::no_exception,
4657  R"({
4658  "method" : "print",
4659  "params" : [
4660  {
4661  "error" : "badSyntax",
4662  "error_code" : 1,
4663  "error_message" : "Syntax error."
4664  }
4665  ]
4666  })"},
4667 
4668  // random
4669  // ----------------------------------------------------------------------
4670  {"random: minimal.",
4671  __LINE__,
4672  {
4673  "random",
4674  },
4675  RPCCallTestData::no_exception,
4676  R"({
4677  "method" : "random",
4678  "params" : [
4679  {
4680  "api_version" : %MAX_API_VER%,
4681  }
4682  ]
4683  })"},
4684  {"random: too many arguments.",
4685  __LINE__,
4686  {"random", "extra"},
4687  RPCCallTestData::no_exception,
4688  R"({
4689  "method" : "random",
4690  "params" : [
4691  {
4692  "error" : "badSyntax",
4693  "error_code" : 1,
4694  "error_message" : "Syntax error."
4695  }
4696  ]
4697  })"},
4698 
4699  // ripple_path_find
4700  // ------------------------------------------------------------
4701  {"ripple_path_find: minimal.",
4702  __LINE__,
4703  {
4704  "ripple_path_find",
4705  R"({"json_argument":true})",
4706  },
4707  RPCCallTestData::no_exception,
4708  R"({
4709  "method" : "ripple_path_find",
4710  "params" : [
4711  {
4712  "api_version" : %MAX_API_VER%,
4713  "json_argument" : true
4714  }
4715  ]
4716  })"},
4717  {"ripple_path_find: ledger index.",
4718  __LINE__,
4719  {"ripple_path_find", R"({"json_argument":true})", "4294967295"},
4720  RPCCallTestData::no_exception,
4721  R"({
4722  "method" : "ripple_path_find",
4723  "params" : [
4724  {
4725  "api_version" : %MAX_API_VER%,
4726  "json_argument" : true,
4727  "ledger_index" : 4294967295
4728  }
4729  ]
4730  })"},
4731  {"ripple_path_find: text ledger index.",
4732  __LINE__,
4733  {"ripple_path_find", R"({"json_argument":true})", "closed"},
4734  RPCCallTestData::no_exception,
4735  R"({
4736  "method" : "ripple_path_find",
4737  "params" : [
4738  {
4739  "api_version" : %MAX_API_VER%,
4740  "json_argument" : true,
4741  "ledger_index" : "closed"
4742  }
4743  ]
4744  })"},
4745  {"ripple_path_find: ledger hash.",
4746  __LINE__,
4747  {"ripple_path_find",
4748  R"({"json_argument":true})",
4749  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"},
4750  RPCCallTestData::no_exception,
4751  R"({
4752  "method" : "ripple_path_find",
4753  "params" : [
4754  {
4755  "api_version" : %MAX_API_VER%,
4756  "json_argument" : true,
4757  "ledger_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
4758  }
4759  ]
4760  })"},
4761 
4762  {"ripple_path_find: too few arguments.",
4763  __LINE__,
4764  {
4765  "ripple_path_find",
4766  },
4767  RPCCallTestData::no_exception,
4768  R"({
4769  "method" : "ripple_path_find",
4770  "params" : [
4771  {
4772  "error" : "badSyntax",
4773  "error_code" : 1,
4774  "error_message" : "Syntax error."
4775  }
4776  ]
4777  })"},
4778  {"ripple_path_find: too many arguments.",
4779  __LINE__,
4780  {"ripple_path_find", R"({"json_argument":true})", "current", "extra"},
4781  RPCCallTestData::no_exception,
4782  R"({
4783  "method" : "ripple_path_find",
4784  "params" : [
4785  {
4786  "error" : "badSyntax",
4787  "error_code" : 1,
4788  "error_message" : "Syntax error."
4789  }
4790  ]
4791  })"},
4792  {"ripple_path_find: invalid json (note extra comma).",
4793  __LINE__,
4794  {
4795  "ripple_path_find",
4796  R"({"json_argument":true,})",
4797  },
4798  RPCCallTestData::no_exception,
4799  R"({
4800  "method" : "ripple_path_find",
4801  "params" : [
4802  {
4803  "error" : "invalidParams",
4804  "error_code" : 31,
4805  "error_message" : "Invalid parameters."
4806  }
4807  ]
4808  })"},
4809  {"ripple_path_find: ledger index too small.",
4810  __LINE__,
4811  {"ripple_path_find", R"({"json_argument":true})", "-1"},
4812  RPCCallTestData::no_exception,
4813  R"({
4814  "method" : "ripple_path_find",
4815  "params" : [
4816  {
4817  "api_version" : %MAX_API_VER%,
4818  "json_argument" : true,
4819  "ledger_index" : 0
4820  }
4821  ]
4822  })"},
4823  {"ripple_path_find: ledger index too big.",
4824  __LINE__,
4825  {"ripple_path_find", R"({"json_argument":true})", "4294967296"},
4826  RPCCallTestData::no_exception,
4827  R"({
4828  "method" : "ripple_path_find",
4829  "params" : [
4830  {
4831  "api_version" : %MAX_API_VER%,
4832  "json_argument" : true,
4833  "ledger_index" : 0
4834  }
4835  ]
4836  })"},
4837  {"ripple_path_find: invalid text ledger index.",
4838  __LINE__,
4839  {"ripple_path_find", R"({"json_argument":true})", "cur"},
4840  RPCCallTestData::no_exception,
4841  R"({
4842  "method" : "ripple_path_find",
4843  "params" : [
4844  {
4845  "api_version" : %MAX_API_VER%,
4846  "json_argument" : true,
4847  "ledger_index" : 0
4848  }
4849  ]
4850  })"},
4851 
4852  // sign
4853  // ------------------------------------------------------------------------
4854  {"sign: minimal.",
4855  __LINE__,
4856  {
4857  "sign",
4858  "my_secret",
4859  R"({"json_argument":true})",
4860  },
4861  RPCCallTestData::no_exception,
4862  R"({
4863  "method" : "sign",
4864  "params" : [
4865  {
4866  "api_version" : %MAX_API_VER%,
4867  "secret" : "my_secret",
4868  "tx_json" : {
4869  "json_argument" : true
4870  }
4871  }
4872  ]
4873  })"},
4874  {"sign: offline.",
4875  __LINE__,
4876  {"sign", "my_secret", R"({"json_argument":true})", "offline"},
4877  RPCCallTestData::no_exception,
4878  R"({
4879  "method" : "sign",
4880  "params" : [
4881  {
4882  "api_version" : %MAX_API_VER%,
4883  "offline" : true,
4884  "secret" : "my_secret",
4885  "tx_json" : {
4886  "json_argument" : true
4887  }
4888  }
4889  ]
4890  })"},
4891  {"sign: too few arguments.",
4892  __LINE__,
4893  {"sign", "contents_of_blob"},
4894  RPCCallTestData::no_exception,
4895  R"({
4896  "method" : "sign",
4897  "params" : [
4898  {
4899  "error" : "badSyntax",
4900  "error_code" : 1,
4901  "error_message" : "Syntax error."
4902  }
4903  ]
4904  })"},
4905  {"sign: too many arguments.",
4906  __LINE__,
4907  {"sign", "my_secret", R"({"json_argument":true})", "offline", "extra"},
4908  RPCCallTestData::no_exception,
4909  R"({
4910  "method" : "sign",
4911  "params" : [
4912  {
4913  "error" : "badSyntax",
4914  "error_code" : 1,
4915  "error_message" : "Syntax error."
4916  }
4917  ]
4918  })"},
4919  {"sign: invalid JSON (note extra comma).",
4920  __LINE__,
4921  {
4922  "sign",
4923  "my_secret",
4924  R"({"json_argument":true,})",
4925  },
4926  RPCCallTestData::no_exception,
4927  R"({
4928  "method" : "sign",
4929  "params" : [
4930  {
4931  "error" : "invalidParams",
4932  "error_code" : 31,
4933  "error_message" : "Invalid parameters."
4934  }
4935  ]
4936  })"},
4937  {"sign: invalid final argument.",
4938  __LINE__,
4939  {"sign", "my_secret", R"({"json_argument":true})", "offlin"},
4940  RPCCallTestData::no_exception,
4941  R"({
4942  "method" : "sign",
4943  "params" : [
4944  {
4945  "error" : "invalidParams",
4946  "error_code" : 31,
4947  "error_message" : "Invalid parameters."
4948  }
4949  ]
4950  })"},
4951 
4952  // sign_for
4953  // --------------------------------------------------------------------
4954  {"sign_for: minimal.",
4955  __LINE__,
4956  {
4957  "sign_for",
4958  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4959  "my_secret",
4960  R"({"json_argument":true})",
4961  },
4962  RPCCallTestData::no_exception,
4963  R"({
4964  "method" : "sign_for",
4965  "params" : [
4966  {
4967  "api_version" : %MAX_API_VER%,
4968  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4969  "secret" : "my_secret",
4970  "tx_json" : {
4971  "json_argument" : true
4972  }
4973  }
4974  ]
4975  })"},
4976  {"sign_for: offline.",
4977  __LINE__,
4978  {"sign_for",
4979  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4980  "my_secret",
4981  R"({"json_argument":true})",
4982  "offline"},
4983  RPCCallTestData::no_exception,
4984  R"({
4985  "method" : "sign_for",
4986  "params" : [
4987  {
4988  "api_version" : %MAX_API_VER%,
4989  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
4990  "offline" : true,
4991  "secret" : "my_secret",
4992  "tx_json" : {
4993  "json_argument" : true
4994  }
4995  }
4996  ]
4997  })"},
4998  {"sign_for: too few arguments.",
4999  __LINE__,
5000  {
5001  "sign_for",
5002  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5003  "my_secret",
5004  },
5005  RPCCallTestData::no_exception,
5006  R"({
5007  "method" : "sign_for",
5008  "params" : [
5009  {
5010  "error" : "badSyntax",
5011  "error_code" : 1,
5012  "error_message" : "Syntax error."
5013  }
5014  ]
5015  })"},
5016  {"sign_for: too many arguments.",
5017  __LINE__,
5018  {"sign_for",
5019  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5020  "my_secret",
5021  R"({"json_argument":true})",
5022  "offline",
5023  "extra"},
5024  RPCCallTestData::no_exception,
5025  R"({
5026  "method" : "sign_for",
5027  "params" : [
5028  {
5029  "error" : "badSyntax",
5030  "error_code" : 1,
5031  "error_message" : "Syntax error."
5032  }
5033  ]
5034  })"},
5035  {"sign_for: invalid json (note extra comma).",
5036  __LINE__,
5037  {
5038  "sign_for",
5039  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5040  "my_secret",
5041  R"({"json_argument":true,})",
5042  },
5043  RPCCallTestData::no_exception,
5044  R"({
5045  "method" : "sign_for",
5046  "params" : [
5047  {
5048  "error" : "invalidParams",
5049  "error_code" : 31,
5050  "error_message" : "Invalid parameters."
5051  }
5052  ]
5053  })"},
5054  {"sign_for: invalid final argument.",
5055  __LINE__,
5056  {"sign_for",
5057  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5058  "my_secret",
5059  R"({"json_argument":true})",
5060  "ofline"},
5061  RPCCallTestData::no_exception,
5062  R"({
5063  "method" : "sign_for",
5064  "params" : [
5065  {
5066  "error" : "invalidParams",
5067  "error_code" : 31,
5068  "error_message" : "Invalid parameters."
5069  }
5070  ]
5071  })"},
5072 
5073  // submit
5074  // ----------------------------------------------------------------------
5075  {"submit: blob.",
5076  __LINE__,
5077  {"submit", "the blob is unvalidated and may be any length..."},
5078  RPCCallTestData::no_exception,
5079  R"({
5080  "method" : "submit",
5081  "params" : [
5082  {
5083  "api_version" : %MAX_API_VER%,
5084  "tx_blob" : "the blob is unvalidated and may be any length..."
5085  }
5086  ]
5087  })"},
5088  {"submit: json.",
5089  __LINE__,
5090  {
5091  "submit",
5092  "my_secret",
5093  R"({"json_argument":true})",
5094  },
5095  RPCCallTestData::no_exception,
5096  R"({
5097  "method" : "submit",
5098  "params" : [
5099  {
5100  "api_version" : %MAX_API_VER%,
5101  "secret" : "my_secret",
5102  "tx_json" : {
5103  "json_argument" : true
5104  }
5105  }
5106  ]
5107  })"},
5108  {"submit: too few arguments.",
5109  __LINE__,
5110  {
5111  "submit",
5112  },
5113  RPCCallTestData::no_exception,
5114  R"({
5115  "method" : "submit",
5116  "params" : [
5117  {
5118  "error" : "badSyntax",
5119  "error_code" : 1,
5120  "error_message" : "Syntax error."
5121  }
5122  ]
5123  })"},
5124  {// Note: I believe this _ought_ to be detected as too many arguments.
5125  "submit: four arguments.",
5126  __LINE__,
5127  {"submit", "my_secret", R"({"json_argument":true})", "offline"},
5128  RPCCallTestData::no_exception,
5129  R"({
5130  "method" : "submit",
5131  "params" : [
5132  {
5133  "api_version" : %MAX_API_VER%,
5134  "offline" : true,
5135  "secret" : "my_secret",
5136  "tx_json" : {
5137  "json_argument" : true
5138  }
5139  }
5140  ]
5141  })"},
5142  {"submit: too many arguments.",
5143  __LINE__,
5144  {"submit", "my_secret", R"({"json_argument":true})", "offline", "extra"},
5145  RPCCallTestData::no_exception,
5146  R"({
5147  "method" : "submit",
5148  "params" : [
5149  {
5150  "error" : "badSyntax",
5151  "error_code" : 1,
5152  "error_message" : "Syntax error."
5153  }
5154  ]
5155  })"},
5156  {"submit: invalid json (note extra comma).",
5157  __LINE__,
5158  {
5159  "submit",
5160  "my_secret",
5161  R"({"json_argument":true,})",
5162  },
5163  RPCCallTestData::no_exception,
5164  R"({
5165  "method" : "submit",
5166  "params" : [
5167  {
5168  "error" : "invalidParams",
5169  "error_code" : 31,
5170  "error_message" : "Invalid parameters."
5171  }
5172  ]
5173  })"},
5174  {"submit: last argument not \"offline\".",
5175  __LINE__,
5176  {"submit", "my_secret", R"({"json_argument":true})", "offlne"},
5177  RPCCallTestData::no_exception,
5178  R"({
5179  "method" : "submit",
5180  "params" : [
5181  {
5182  "error" : "invalidParams",
5183  "error_code" : 31,
5184  "error_message" : "Invalid parameters."
5185  }
5186  ]
5187  })"},
5188 
5189  // submit_multisigned
5190  // ----------------------------------------------------------
5191  {"submit_multisigned: json.",
5192  __LINE__,
5193  {
5194  "submit_multisigned",
5195  R"({"json_argument":true})",
5196  },
5197  RPCCallTestData::no_exception,
5198  R"({
5199  "method" : "submit_multisigned",
5200  "params" : [
5201  {
5202  "api_version" : %MAX_API_VER%,
5203  "tx_json" : {
5204  "json_argument" : true
5205  }
5206  }
5207  ]
5208  })"},
5209  {"submit_multisigned: too few arguments.",
5210  __LINE__,
5211  {
5212  "submit_multisigned",
5213  },
5214  RPCCallTestData::no_exception,
5215  R"({
5216  "method" : "submit_multisigned",
5217  "params" : [
5218  {
5219  "error" : "badSyntax",
5220  "error_code" : 1,
5221  "error_message" : "Syntax error."
5222  }
5223  ]
5224  })"},
5225  {"submit_multisigned: too many arguments.",
5226  __LINE__,
5227  {"submit_multisigned", R"({"json_argument":true})", "extra"},
5228  RPCCallTestData::no_exception,
5229  R"({
5230  "method" : "submit_multisigned",
5231  "params" : [
5232  {
5233  "error" : "badSyntax",
5234  "error_code" : 1,
5235  "error_message" : "Syntax error."
5236  }
5237  ]
5238  })"},
5239  {"submit_multisigned: invalid json (note extra comma).",
5240  __LINE__,
5241  {
5242  "submit_multisigned",
5243  R"({"json_argument":true,})",
5244  },
5245  RPCCallTestData::no_exception,
5246  R"({
5247  "method" : "submit_multisigned",
5248  "params" : [
5249  {
5250  "error" : "invalidParams",
5251  "error_code" : 31,
5252  "error_message" : "Invalid parameters."
5253  }
5254  }
5255  ]
5256  })"},
5257 
5258  // server_info
5259  // -----------------------------------------------------------------
5260  {"server_info: minimal.",
5261  __LINE__,
5262  {
5263  "server_info",
5264  },
5265  RPCCallTestData::no_exception,
5266  R"({
5267  "method" : "server_info",
5268  "params" : [
5269  {
5270  "api_version" : %MAX_API_VER%,
5271  }
5272  ]
5273  })"},
5274  {"server_info: counters.",
5275  __LINE__,
5276  {"server_info", "counters"},
5277  RPCCallTestData::no_exception,
5278  R"({
5279  "method" : "server_info",
5280  "params" : [
5281  {
5282  "api_version" : %MAX_API_VER%,
5283  "counters" : true
5284  }
5285  ]
5286  })"},
5287  {"server_info: too many arguments.",
5288  __LINE__,
5289  {"server_info", "counters", "extra"},
5290  RPCCallTestData::no_exception,
5291  R"({
5292  "method" : "server_info",
5293  "params" : [
5294  {
5295  "error" : "badSyntax",
5296  "error_code" : 1,
5297  "error_message" : "Syntax error."
5298  }
5299  ]
5300  })"},
5301  {"server_info: non-counters argument.",
5302  __LINE__,
5303  {"server_info", "counter"},
5304  RPCCallTestData::no_exception,
5305  R"({
5306  "method" : "server_info",
5307  "params" : [
5308  {
5309  "api_version" : %MAX_API_VER%,
5310  }
5311  ]
5312  })"},
5313 
5314  // server_state
5315  // ----------------------------------------------------------------
5316  {"server_state: minimal.",
5317  __LINE__,
5318  {
5319  "server_state",
5320  },
5321  RPCCallTestData::no_exception,
5322  R"({
5323  "method" : "server_state",
5324  "params" : [
5325  {
5326  "api_version" : %MAX_API_VER%,
5327  }
5328  ]
5329  })"},
5330  {"server_state: counters.",
5331  __LINE__,
5332  {"server_state", "counters"},
5333  RPCCallTestData::no_exception,
5334  R"({
5335  "method" : "server_state",
5336  "params" : [
5337  {
5338  "api_version" : %MAX_API_VER%,
5339  "counters" : true
5340  }
5341  ]
5342  })"},
5343  {"server_state: too many arguments.",
5344  __LINE__,
5345  {"server_state", "counters", "extra"},
5346  RPCCallTestData::no_exception,
5347  R"({
5348  "method" : "server_state",
5349  "params" : [
5350  {
5351  "error" : "badSyntax",
5352  "error_code" : 1,
5353  "error_message" : "Syntax error."
5354  }
5355  ]
5356  })"},
5357  {"server_state: non-counters argument.",
5358  __LINE__,
5359  {"server_state", "counter"},
5360  RPCCallTestData::no_exception,
5361  R"({
5362  "method" : "server_state",
5363  "params" : [
5364  {
5365  "api_version" : %MAX_API_VER%,
5366  }
5367  ]
5368  })"},
5369 
5370  // stop
5371  // ------------------------------------------------------------------------
5372  {"stop: minimal.",
5373  __LINE__,
5374  {
5375  "stop",
5376  },
5377  RPCCallTestData::no_exception,
5378  R"({
5379  "method" : "stop",
5380  "params" : [
5381  {
5382  "api_version" : %MAX_API_VER%,
5383  }
5384  ]
5385  })"},
5386  {"stop: too many arguments.",
5387  __LINE__,
5388  {"stop", "extra"},
5389  RPCCallTestData::no_exception,
5390  R"({
5391  "method" : "stop",
5392  "params" : [
5393  {
5394  "error" : "badSyntax",
5395  "error_code" : 1,
5396  "error_message" : "Syntax error."
5397  }
5398  ]
5399  })"},
5400 
5401  // transaction_entry
5402  // -----------------------------------------------------------
5403  {"transaction_entry: ledger index.",
5404  __LINE__,
5405  {"transaction_entry",
5406  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5407  "4294967295"},
5408  RPCCallTestData::no_exception,
5409  R"({
5410  "method" : "transaction_entry",
5411  "params" : [
5412  {
5413  "api_version" : %MAX_API_VER%,
5414  "ledger_index" : 4294967295,
5415  "tx_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
5416  }
5417  ]
5418  })"},
5419  {"transaction_entry: text ledger index.",
5420  __LINE__,
5421  {"transaction_entry",
5422  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5423  "current"},
5424  RPCCallTestData::no_exception,
5425  R"({
5426  "method" : "transaction_entry",
5427  "params" : [
5428  {
5429  "api_version" : %MAX_API_VER%,
5430  "ledger_index" : "current",
5431  "tx_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
5432  }
5433  ]
5434  })"},
5435  {"transaction_entry: ledger hash.",
5436  __LINE__,
5437  {"transaction_entry",
5438  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5439  "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210"},
5440  RPCCallTestData::no_exception,
5441  R"({
5442  "method" : "transaction_entry",
5443  "params" : [
5444  {
5445  "api_version" : %MAX_API_VER%,
5446  "ledger_hash" : "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210",
5447  "tx_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
5448  }
5449  ]
5450  })"},
5451  {"transaction_entry: too few arguments.",
5452  __LINE__,
5453  {
5454  "transaction_entry",
5455  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5456  },
5457  RPCCallTestData::no_exception,
5458  R"({
5459  "method" : "transaction_entry",
5460  "params" : [
5461  {
5462  "error" : "badSyntax",
5463  "error_code" : 1,
5464  "error_message" : "Syntax error."
5465  }
5466  ]
5467  })"},
5468  {"transaction_entry: too many arguments.",
5469  __LINE__,
5470  {"transaction_entry",
5471  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5472  "validated",
5473  "extra"},
5474  RPCCallTestData::no_exception,
5475  R"({
5476  "method" : "transaction_entry",
5477  "params" : [
5478  {
5479  "error" : "badSyntax",
5480  "error_code" : 1,
5481  "error_message" : "Syntax error."
5482  }
5483  ]
5484  })"},
5485  {"transaction_entry: short tx_hash.",
5486  __LINE__,
5487  {
5488  "transaction_entry",
5489  "123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5490  "validated",
5491  },
5492  RPCCallTestData::no_exception,
5493  R"({
5494  "method" : "transaction_entry",
5495  "params" : [
5496  {
5497  "error" : "invalidParams",
5498  "error_code" : 31,
5499  "error_message" : "Invalid parameters."
5500  }
5501  ]
5502  })"},
5503  {"transaction_entry: long tx_hash.",
5504  __LINE__,
5505  {
5506  "transaction_entry",
5507  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUVW",
5508  "validated",
5509  },
5510  RPCCallTestData::no_exception,
5511  R"({
5512  "method" : "transaction_entry",
5513  "params" : [
5514  {
5515  "error" : "invalidParams",
5516  "error_code" : 31,
5517  "error_message" : "Invalid parameters."
5518  }
5519  ]
5520  })"},
5521  {"transaction_entry: small ledger index.",
5522  __LINE__,
5523  {
5524  "transaction_entry",
5525  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5526  "0",
5527  },
5528  RPCCallTestData::no_exception,
5529  R"({
5530  "method" : "transaction_entry",
5531  "params" : [
5532  {
5533  "error" : "invalidParams",
5534  "error_code" : 31,
5535  "error_message" : "Invalid parameters."
5536  }
5537  ]
5538  })"},
5539  {"transaction_entry: large ledger index.",
5540  __LINE__,
5541  {
5542  "transaction_entry",
5543  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5544  "4294967296",
5545  },
5546  RPCCallTestData::no_exception,
5547  R"({
5548  "method" : "transaction_entry",
5549  "params" : [
5550  {
5551  "error" : "invalidParams",
5552  "error_code" : 31,
5553  "error_message" : "Invalid parameters."
5554  }
5555  ]
5556  })"},
5557  {"transaction_entry: short ledger hash.",
5558  __LINE__,
5559  {
5560  "transaction_entry",
5561  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5562  "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA987654321",
5563  },
5564  RPCCallTestData::no_exception,
5565  R"({
5566  "method" : "transaction_entry",
5567  "params" : [
5568  {
5569  "error" : "invalidParams",
5570  "error_code" : 31,
5571  "error_message" : "Invalid parameters."
5572  }
5573  ]
5574  })"},
5575  {"transaction_entry: long ledger hash.",
5576  __LINE__,
5577  {
5578  "transaction_entry",
5579  "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
5580  "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210Z",
5581  },
5582  RPCCallTestData::no_exception,
5583  R"({
5584  "method" : "transaction_entry",
5585  "params" : [
5586  {
5587  "error" : "invalidParams",
5588  "error_code" : 31,
5589  "error_message" : "Invalid parameters."
5590  }
5591  ]
5592  })"},
5593 
5594  // tx
5595  // --------------------------------------------------------------------------
5596  {"tx: ctid. minimal",
5597  __LINE__,
5598  {"tx", "FFFFFFFFFFFFFFFF", "1", "2"},
5599  RPCCallTestData::no_exception,
5600  R"({
5601  "method" : "tx",
5602  "params" : [
5603  {
5604  "api_version" : %MAX_API_VER%,
5605  "ctid" : "FFFFFFFFFFFFFFFF",
5606  "max_ledger" : "2",
5607  "min_ledger" : "1"
5608  }
5609  ]
5610  })"},
5611  {"tx: ctid. binary",
5612  __LINE__,
5613  {"tx", "FFFFFFFFFFFFFFFF", "binary", "1", "2"},
5614  RPCCallTestData::no_exception,
5615  R"({
5616  "method" : "tx",
5617  "params" : [
5618  {
5619  "api_version" : %MAX_API_VER%,
5620  "binary" : true,
5621  "ctid" : "FFFFFFFFFFFFFFFF",
5622  "max_ledger" : "2",
5623  "min_ledger" : "1"
5624  }
5625  ]
5626  })"},
5627  {"tx: minimal.",
5628  __LINE__,
5629  {"tx", "transaction_hash_is_not_validated"},
5630  RPCCallTestData::no_exception,
5631  R"({
5632  "method" : "tx",
5633  "params" : [
5634  {
5635  "api_version" : %MAX_API_VER%,
5636  "transaction" : "transaction_hash_is_not_validated"
5637  }
5638  ]
5639  })"},
5640  {"tx: binary.",
5641  __LINE__,
5642  {"tx", "transaction_hash_is_not_validated", "binary"},
5643  RPCCallTestData::no_exception,
5644  R"({
5645  "method" : "tx",
5646  "params" : [
5647  {
5648  "api_version" : %MAX_API_VER%,
5649  "binary" : true,
5650  "transaction" : "transaction_hash_is_not_validated"
5651  }
5652  ]
5653  })"},
5654  {"tx: too few arguments.",
5655  __LINE__,
5656  {
5657  "tx",
5658  },
5659  RPCCallTestData::no_exception,
5660  R"({
5661  "method" : "tx",
5662  "params" : [
5663  {
5664  "error" : "badSyntax",
5665  "error_code" : 1,
5666  "error_message" : "Syntax error."
5667  }
5668  ]
5669  })"},
5670  {"tx: too many arguments.",
5671  __LINE__,
5672  {"tx", "transaction_hash_is_not_validated", "binary", "1", "2", "extra"},
5673  RPCCallTestData::no_exception,
5674  R"({
5675  "method" : "tx",
5676  "params" : [
5677  {
5678  "error" : "badSyntax",
5679  "error_code" : 1,
5680  "error_message" : "Syntax error."
5681  }
5682  ]
5683  })"},
5684  {"tx: invalid final argument is apparently ignored.",
5685  __LINE__,
5686  {"tx", "transaction_hash_is_not_validated", "bin"},
5687  RPCCallTestData::no_exception,
5688  R"({
5689  "method" : "tx",
5690  "params" : [
5691  {
5692  "api_version" : %MAX_API_VER%,
5693  "transaction" : "transaction_hash_is_not_validated"
5694  }
5695  ]
5696  })"},
5697 
5698  // tx_account
5699  // ------------------------------------------------------------------
5700  {"tx_account: minimal.",
5701  __LINE__,
5702  {"tx_account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
5703  RPCCallTestData::no_exception,
5704  R"({
5705  "method" : "tx_account",
5706  "params" : [
5707  {
5708  "api_version" : %MAX_API_VER%,
5709  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5710  }
5711  ]
5712  })"},
5713  {"tx_account: ledger_index .",
5714  __LINE__,
5715  {"tx_account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "4294967295"},
5716  RPCCallTestData::no_exception,
5717  R"({
5718  "method" : "tx_account",
5719  "params" : [
5720  {
5721  "api_version" : %MAX_API_VER%,
5722  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5723  "ledger_index" : 4294967295
5724  }
5725  ]
5726  })"},
5727  {"tx_account: ledger_index plus trailing params.",
5728  __LINE__,
5729  {"tx_account",
5730  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5731  "707",
5732  "forward",
5733  "binary",
5734  "count"},
5735  RPCCallTestData::no_exception,
5736  R"({
5737  "method" : "tx_account",
5738  "params" : [
5739  {
5740  "api_version" : %MAX_API_VER%,
5741  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5742  "binary" : true,
5743  "count" : true,
5744  "forward" : true,
5745  "ledger_index" : 707
5746  }
5747  ]
5748  })"},
5749  {"tx_account: ledger_index_min and _max.",
5750  __LINE__,
5751  {"tx_account",
5752  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5753  "2147483647",
5754  "2147483647"},
5755  RPCCallTestData::no_exception,
5756  R"({
5757  "method" : "tx_account",
5758  "params" : [
5759  {
5760  "api_version" : %MAX_API_VER%,
5761  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5762  "ledger_index_max" : 2147483647,
5763  "ledger_index_min" : 2147483647
5764  }
5765  ]
5766  })"},
5767  {"tx_account: ledger_index_min and _max plus trailing params.",
5768  __LINE__,
5769  {"tx_account",
5770  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5771  "33333",
5772  "2147483647",
5773  "binary",
5774  "count",
5775  "forward"},
5776  RPCCallTestData::no_exception,
5777  R"({
5778  "method" : "tx_account",
5779  "params" : [
5780  {
5781  "api_version" : %MAX_API_VER%,
5782  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5783  "binary" : true,
5784  "count" : true,
5785  "forward" : true,
5786  "ledger_index_max" : 2147483647,
5787  "ledger_index_min" : 33333
5788  }
5789  ]
5790  })"},
5791  {"tx_account: ledger_index_min and _max plus limit.",
5792  __LINE__,
5793  {"tx_account",
5794  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5795  "-1",
5796  "2147483647",
5797  "2147483647"},
5798  RPCCallTestData::no_exception,
5799  R"({
5800  "method" : "tx_account",
5801  "params" : [
5802  {
5803  "api_version" : %MAX_API_VER%,
5804  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5805  "ledger_index_max" : 2147483647,
5806  "ledger_index_min" : -1,
5807  "limit" : 2147483647
5808  }
5809  ]
5810  })"},
5811  {"tx_account: ledger_index_min and _max, limit, trailing args.",
5812  __LINE__,
5813  {"tx_account",
5814  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5815  "1",
5816  "1",
5817  "-1",
5818  "count",
5819  "forward",
5820  "binary"},
5821  RPCCallTestData::no_exception,
5822  R"({
5823  "method" : "tx_account",
5824  "params" : [
5825  {
5826  "api_version" : %MAX_API_VER%,
5827  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5828  "binary" : true,
5829  "count" : true,
5830  "forward" : true,
5831  "ledger_index_max" : 1,
5832  "ledger_index_min" : 1,
5833  "limit" : -1
5834  }
5835  ]
5836  })"},
5837  {"tx_account: too few arguments.",
5838  __LINE__,
5839  {
5840  "tx_account",
5841  },
5842  RPCCallTestData::no_exception,
5843  R"({
5844  "method" : "tx_account",
5845  "params" : [
5846  {
5847  "error" : "badSyntax",
5848  "error_code" : 1,
5849  "error_message" : "Syntax error."
5850  }
5851  ]
5852  })"},
5853  {"tx_account: too many arguments.",
5854  __LINE__,
5855  {"tx_account",
5856  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5857  "589",
5858  "590",
5859  "67",
5860  "extra",
5861  "descending",
5862  "count",
5863  "binary"},
5864  RPCCallTestData::no_exception,
5865  R"({
5866  "method" : "tx_account",
5867  "params" : [
5868  {
5869  "error" : "badSyntax",
5870  "error_code" : 1,
5871  "error_message" : "Syntax error."
5872  }
5873  ]
5874  })"},
5875  {
5876  "tx_account: invalid accountID.",
5877  __LINE__,
5878  {"tx_account", "rHb9CJAWyB4rj9!VRWn96DkukG4bwdtyTh"},
5879  RPCCallTestData::no_exception,
5880  R"({
5881  "method" : "tx_account",
5882  "params" : [
5883  {
5884  "error" : "actMalformed",
5885  "error_code" : 35,
5886  "error_message" : "Account malformed."
5887  }
5888  ]
5889  })",
5890  },
5891  {
5892  // Note: not currently detected as bad input.
5893  "tx_account: invalid ledger.",
5894  __LINE__,
5895  {"tx_account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-478.7"},
5896  RPCCallTestData::no_exception,
5897  R"({
5898  "method" : "tx_account",
5899  "params" : [
5900  {
5901  "api_version" : %MAX_API_VER%,
5902  "account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5903  "ledger_index" : 0
5904  }
5905  ]
5906  })",
5907  },
5908  {
5909  "tx_account: max less than min.",
5910  __LINE__,
5911  {"tx_account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "580", "579"},
5912  RPCCallTestData::no_exception,
5913  RPC::apiMaximumSupportedVersion == 1 ?
5914  R"({
5915  "method" : "tx_account",
5916  "params" : [
5917  {
5918  "error" : "lgrIdxsInvalid",
5919  "error_code" : 55,
5920  "error_message" : "Ledger indexes invalid."
5921  }
5922  ]
5923  })"
5924  :
5925  R"({
5926  "method" : "tx_account",
5927  "params" : [
5928  {
5929  "error" : "notSynced",
5930  "error_code" : 55,
5931  "error_message" : "Not synced to the network."
5932  }
5933  ]
5934  })",
5935  },
5936  {
5937  // Note: this really shouldn't throw, but does at the moment.
5938  "tx_account: min large but still valid.",
5939  __LINE__,
5940  {"tx_account",
5941  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5942  "2147483648",
5943  "2147483648"},
5944  RPCCallTestData::bad_cast,
5945  R"()",
5946  },
5947  {
5948  // Note: this really shouldn't throw, but does at the moment.
5949  "tx_account: max large but still valid.",
5950  __LINE__,
5951  {"tx_account",
5952  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5953  "2147483647",
5954  "2147483648"},
5955  RPCCallTestData::bad_cast,
5956  R"()",
5957  },
5958  {
5959  // Note: this really shouldn't throw, but does at the moment.
5960  "tx_account: large limit.",
5961  __LINE__,
5962  {"tx_account",
5963  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5964  "-1",
5965  "-1",
5966  "2147483648"},
5967  RPCCallTestData::bad_cast,
5968  R"()",
5969  },
5970  {
5971  // Note: this really shouldn't throw, but does at the moment.
5972  "tx_account: non-integer min.",
5973  __LINE__,
5974  {"tx_account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "Binary", "-1"},
5975  RPCCallTestData::bad_cast,
5976  R"()",
5977  },
5978  {
5979  // Note: this really shouldn't throw, but does at the moment.
5980  "tx_account: non-integer max.",
5981  __LINE__,
5982  {"tx_account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh", "-1", "counts"},
5983  RPCCallTestData::bad_cast,
5984  R"()",
5985  },
5986  {
5987  // Note: this really shouldn't throw, but does at the moment.
5988  "tx_account: non-integer limit.",
5989  __LINE__,
5990  {"tx_account",
5991  "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
5992  "-1",
5993  "-1",
5994  "decending"},
5995  RPCCallTestData::bad_cast,
5996  R"()",
5997  },
5998 
5999  // tx_history
6000  // ------------------------------------------------------------------
6001  {"tx_history: minimal.",
6002  __LINE__,
6003  {"tx_history", "0"},
6004  RPCCallTestData::no_exception,
6005  R"({
6006  "method" : "tx_history",
6007  "params" : [
6008  {
6009  "api_version" : %MAX_API_VER%,
6010  "start" : 0
6011  }
6012  ]
6013  })"},
6014  {"tx_history: too few arguments.",
6015  __LINE__,
6016  {
6017  "tx_history",
6018  },
6019  RPCCallTestData::no_exception,
6020  R"({
6021  "method" : "tx_history",
6022  "params" : [
6023  {
6024  "error" : "badSyntax",
6025  "error_code" : 1,
6026  "error_message" : "Syntax error."
6027  }
6028  ]
6029  })"},
6030  {"tx_history: too many arguments.",
6031  __LINE__,
6032  {"tx_history", "0", "1"},
6033  RPCCallTestData::no_exception,
6034  R"({
6035  "method" : "tx_history",
6036  "params" : [
6037  {
6038  "error" : "badSyntax",
6039  "error_code" : 1,
6040  "error_message" : "Syntax error."
6041  }
6042  ]
6043  })"},
6044  {
6045  // Note: this really shouldn't throw, but does at the moment.
6046  "tx_history: start too small.",
6047  __LINE__,
6048  {"tx_history", "-1"},
6049  RPCCallTestData::bad_cast,
6050  R"()",
6051  },
6052  {
6053  // Note: this really shouldn't throw, but does at the moment.
6054  "tx_history: start too big.",
6055  __LINE__,
6056  {"tx_history", "4294967296"},
6057  RPCCallTestData::bad_cast,
6058  R"()",
6059  },
6060  {
6061  // Note: this really shouldn't throw, but does at the moment.
6062  "tx_history: start not integer.",
6063  __LINE__,
6064  {"tx_history", "beginning"},
6065  RPCCallTestData::bad_cast,
6066  R"()",
6067  },
6068 
6069  // unl_list
6070  // --------------------------------------------------------------------
6071  {"unl_list: minimal.",
6072  __LINE__,
6073  {
6074  "unl_list",
6075  },
6076  RPCCallTestData::no_exception,
6077  R"({
6078  "method" : "unl_list",
6079  "params" : [
6080  {
6081  "api_version" : %MAX_API_VER%,
6082  }
6083  ]
6084  })"},
6085  {"unl_list: too many arguments.",
6086  __LINE__,
6087  {"unl_list", "extra"},
6088  RPCCallTestData::no_exception,
6089  R"({
6090  "method" : "unl_list",
6091  "params" : [
6092  {
6093  "error" : "badSyntax",
6094  "error_code" : 1,
6095  "error_message" : "Syntax error."
6096  }
6097  ]
6098  })"},
6099 
6100  // validation_create
6101  // -----------------------------------------------------------
6102  {"validation_create: minimal.",
6103  __LINE__,
6104  {
6105  "validation_create",
6106  },
6107  RPCCallTestData::no_exception,
6108  R"({
6109  "method" : "validation_create",
6110  "params" : [
6111  {
6112  "api_version" : %MAX_API_VER%,
6113  }
6114  ]
6115  })"},
6116  {"validation_create: with secret.",
6117  __LINE__,
6118  {"validation_create", "the form of the secret is not validated"},
6119  RPCCallTestData::no_exception,
6120  R"({
6121  "method" : "validation_create",
6122  "params" : [
6123  {
6124  "api_version" : %MAX_API_VER%,
6125  "secret" : "the form of the secret is not validated"
6126  }
6127  ]
6128  })"},
6129  {"validation_create: too many arguments.",
6130  __LINE__,
6131  {"validation_create", "the form of the secret is not validated", "extra"},
6132  RPCCallTestData::no_exception,
6133  R"({
6134  "method" : "validation_create",
6135  "params" : [
6136  {
6137  "error" : "badSyntax",
6138  "error_code" : 1,
6139  "error_message" : "Syntax error."
6140  }
6141  ]
6142  })"},
6143 
6144  // version
6145  // ---------------------------------------------------------------------
6146  {"version: minimal.",
6147  __LINE__,
6148  {
6149  "version",
6150  },
6151  RPCCallTestData::no_exception,
6152  R"({
6153  "method" : "version",
6154  "params" : [
6155  {
6156  "api_version" : %MAX_API_VER%,
6157  }
6158  ]
6159  })"},
6160  {"version: too many arguments.",
6161  __LINE__,
6162  {"version", "extra"},
6163  RPCCallTestData::no_exception,
6164  R"({
6165  "method" : "version",
6166  "params" : [
6167  {
6168  "error" : "badSyntax",
6169  "error_code" : 1,
6170  "error_message" : "Syntax error."
6171  }
6172  ]
6173  })"},
6174 
6175  // wallet_propose
6176  // --------------------------------------------------------------
6177  {"wallet_propose: minimal.",
6178  __LINE__,
6179  {
6180  "wallet_propose",
6181  },
6182  RPCCallTestData::no_exception,
6183  R"({
6184  "method" : "wallet_propose",
6185  "params" : [
6186  {
6187  "api_version" : %MAX_API_VER%,
6188  }
6189  ]
6190  })"},
6191  {"wallet_propose: with passphrase.",
6192  __LINE__,
6193  {"wallet_propose", "the form of the passphrase is not validated"},
6194  RPCCallTestData::no_exception,
6195  R"({
6196  "method" : "wallet_propose",
6197  "params" : [
6198  {
6199  "api_version" : %MAX_API_VER%,
6200  "passphrase" : "the form of the passphrase is not validated"
6201  }
6202  ]
6203  })"},
6204  {"wallet_propose: too many arguments.",
6205  __LINE__,
6206  {"wallet_propose", "the form of the passphrase is not validated", "extra"},
6207  RPCCallTestData::no_exception,
6208  R"({
6209  "method" : "wallet_propose",
6210  "params" : [
6211  {
6212  "error" : "badSyntax",
6213  "error_code" : 1,
6214  "error_message" : "Syntax error."
6215  }
6216  ]
6217  })"},
6218 
6219  // internal
6220  // --------------------------------------------------------------------
6221  {"internal: minimal.",
6222  __LINE__,
6223  {"internal", "command_name"},
6224  RPCCallTestData::no_exception,
6225  R"({
6226  "method" : "internal",
6227  "params" : [
6228  {
6229  "api_version" : %MAX_API_VER%,
6230  "internal_command" : "command_name",
6231  "params" : []
6232  }
6233  ]
6234  })"},
6235  {"internal: with parameters.",
6236  __LINE__,
6237  {"internal",
6238  "command_name",
6239  "string_arg",
6240  "1",
6241  "-1",
6242  "4294967296",
6243  "3.14159"},
6244  RPCCallTestData::no_exception,
6245  R"({
6246  "method" : "internal",
6247  "params" : [
6248  {
6249  "api_version" : %MAX_API_VER%,
6250  "internal_command" : "command_name",
6251  "params" : [ "string_arg", "1", "-1", "4294967296", "3.14159" ]
6252  }
6253  ]
6254  })"},
6255  {"internal: too few arguments.",
6256  __LINE__,
6257  {
6258  "internal",
6259  },
6260  RPCCallTestData::no_exception,
6261  R"({
6262  "method" : "internal",
6263  "params" : [
6264  {
6265  "error" : "badSyntax",
6266  "error_code" : 1,
6267  "error_message" : "Syntax error."
6268  }
6269  ]
6270  })"},
6271 
6272  // path_find
6273  // -------------------------------------------------------------------
6274  {"path_find: minimal.",
6275  __LINE__,
6276  {
6277  "path_find",
6278  },
6279  RPCCallTestData::no_exception,
6280  R"({
6281  "method" : "path_find",
6282  "params" : [
6283  {
6284  "error" : "noEvents",
6285  "error_code" : 7,
6286  "error_message" : "Current transport does not support events."
6287  }
6288  ]
6289  })"},
6290  {"path_find: with arguments.",
6291  __LINE__,
6292  {"path_find", "string_arg", "1", "-1", "4294967296", "3.14159"},
6293  RPCCallTestData::no_exception,
6294  R"({
6295  "method" : "path_find",
6296  "params" : [
6297  {
6298  "error" : "noEvents",
6299  "error_code" : 7,
6300  "error_message" : "Current transport does not support events."
6301  }
6302  ]
6303  })"},
6304 
6305  // subscribe
6306  // -------------------------------------------------------------------
6307  {"subscribe: minimal.",
6308  __LINE__,
6309  {
6310  "subscribe",
6311  },
6312  RPCCallTestData::no_exception,
6313  R"({
6314  "method" : "subscribe",
6315  "params" : [
6316  {
6317  "error" : "noEvents",
6318  "error_code" : 7,
6319  "error_message" : "Current transport does not support events."
6320  }
6321  ]
6322  })"},
6323  {"subscribe: with arguments.",
6324  __LINE__,
6325  {"subscribe", "string_arg", "1", "-1", "4294967296", "3.14159"},
6326  RPCCallTestData::no_exception,
6327  R"({
6328  "method" : "subscribe",
6329  "params" : [
6330  {
6331  "error" : "noEvents",
6332  "error_code" : 7,
6333  "error_message" : "Current transport does not support events."
6334  }
6335  ]
6336  })"},
6337 
6338  // unsubscribe
6339  // -----------------------------------------------------------------
6340  {"unsubscribe: minimal.",
6341  __LINE__,
6342  {
6343  "unsubscribe",
6344  },
6345  RPCCallTestData::no_exception,
6346  R"({
6347  "method" : "unsubscribe",
6348  "params" : [
6349  {
6350  "error" : "noEvents",
6351  "error_code" : 7,
6352  "error_message" : "Current transport does not support events."
6353  }
6354  ]
6355  })"},
6356  {"unsubscribe: with arguments.",
6357  __LINE__,
6358  {"unsubscribe", "string_arg", "1", "-1", "4294967296", "3.14159"},
6359  RPCCallTestData::no_exception,
6360  R"({
6361  "method" : "unsubscribe",
6362  "params" : [
6363  {
6364  "error" : "noEvents",
6365  "error_code" : 7,
6366  "error_message" : "Current transport does not support events."
6367  }
6368  ]
6369  })"},
6370 
6371  // unknown_command
6372  // -------------------------------------------------------------
6373  {"unknown_command: minimal.",
6374  __LINE__,
6375  {
6376  "unknown_command",
6377  },
6378  RPCCallTestData::no_exception,
6379  R"({
6380  "method" : "unknown_command",
6381  "params" : [
6382  {
6383  "api_version" : %MAX_API_VER%,
6384  }
6385  ]
6386  })"},
6387  {"unknown_command: with arguments.",
6388  __LINE__,
6389  {"unknown_command", "string_arg", "1", "-1", "4294967296", "3.14159"},
6390  RPCCallTestData::no_exception,
6391  R"({
6392  "method" : "unknown_command",
6393  "params" : [
6394  {
6395  "api_version" : %MAX_API_VER%,
6396  "params" : [ "string_arg", "1", "-1", "4294967296", "3.14159" ]
6397  }
6398  ]
6399  })"},
6400 };
6401 
6402 std::string
6403 updateAPIVersionString(const char* const req)
6404 {
6405  static std::string version_str =
6406  std::to_string(RPC::apiMaximumSupportedVersion);
6407  static auto place_holder = "%MAX_API_VER%";
6408  std::string jr(req);
6409  boost::replace_all(jr, place_holder, version_str);
6410  return jr;
6411 }
6412 
6413 std::unique_ptr<Config>
6414 makeNetworkConfig(uint32_t networkID)
6415 {
6416  using namespace test::jtx;
6417  return envconfig([&](std::unique_ptr<Config> cfg) {
6418  cfg->NETWORK_ID = networkID;
6419  return cfg;
6420  });
6421 }
6422 
6423 class RPCCall_test : public beast::unit_test::suite
6424 {
6425 public:
6426  void
6427  testRPCCall()
6428  {
6429  testcase << "RPCCall";
6430 
6431  test::jtx::Env env(
6432  *this, makeNetworkConfig(11111)); // Used only for its Journal.
6433 
6434  // For each RPCCall test.
6435  for (RPCCallTestData const& rpcCallTest : rpcCallTestArray)
6436  {
6437  std::vector<std::string> const args{
6438  rpcCallTest.args.begin(), rpcCallTest.args.end()};
6439 
6440  // Note that, over the long term, none of these tests should
6441  // throw. But, for the moment, some of them do. So handle it.
6442  Json::Value got;
6443  try
6444  {
6445  got = cmdLineToJSONRPC(args, env.journal);
6446  }
6447  catch (std::bad_cast const&)
6448  {
6449  if ((rpcCallTest.throwsWhat == RPCCallTestData::bad_cast) &&
6450  (std::strlen(rpcCallTest.exp) == 0))
6451  {
6452  pass();
6453  }
6454  else
6455  {
6456  fail(rpcCallTest.description, __FILE__, rpcCallTest.line);
6457  }
6458  // Try the next test.
6459  continue;
6460  }
6461 
6462  Json::Value exp;
6463  Json::Reader{}.parse(updateAPIVersionString(rpcCallTest.exp), exp);
6464 
6465  // Lambda to remove the "params[0u]:error_code" field if present.
6466  // Error codes are not expected to be stable between releases.
6467  auto rmErrorCode = [](Json::Value& json) {
6468  if (json.isMember(jss::params) && json[jss::params].isArray() &&
6469  json[jss::params].size() > 0 &&
6470  json[jss::params][0u].isObject())
6471  {
6472  json[jss::params][0u].removeMember(jss::error_code);
6473  }
6474  };
6475  rmErrorCode(got);
6476  rmErrorCode(exp);
6477 
6478  // Pass if we didn't expect a throw and we got what we expected.
6479  if ((rpcCallTest.throwsWhat == RPCCallTestData::no_exception) &&
6480  (got == exp))
6481  {
6482  pass();
6483  }
6484  else
6485  {
6486  fail(rpcCallTest.description, __FILE__, rpcCallTest.line);
6487  }
6488  }
6489  }
6490 
6491  void
6492  run() override
6493  {
6494  testRPCCall();
6495  }
6496 };
6497 
6498 BEAST_DEFINE_TESTSUITE(RPCCall, app, ripple);
6499 
6500 } // namespace test
6501 } // namespace ripple
ripple::test::jtx::json
Inject raw JSON.
Definition: jtx_json.h:31
std::strlen
T strlen(T... args)
ripple::test::RPCCallTestData::no_exception
@ no_exception
Definition: RPCCall_test.cpp:40
std::string
STL class.
vector
ripple::test::RPCCallTestData::args
const std::vector< char const * > args
Definition: RPCCall_test.cpp:37
ripple::test::jtx::Env::journal
const beast::Journal journal
Definition: Env.h:145
Json::Reader
Unserialize a JSON document into a Value.
Definition: json_reader.h:36
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:49
ripple::test::makeNetworkConfig
std::unique_ptr< Config > makeNetworkConfig(uint32_t networkID)
Definition: RPCCall_test.cpp:6414
std::bad_cast
STL class.
ripple::test::RPCCallTestData::operator=
RPCCallTestData & operator=(RPCCallTestData const &)=delete
ripple::test::RPCCallTestData::RPCCallTestData
RPCCallTestData(char const *description_, int line_, std::initializer_list< char const * > const &args_, Exception throwsWhat_, char const *exp_)
Definition: RPCCall_test.cpp:46
ripple::test::RPCCallTestData::throwsWhat
const Exception throwsWhat
Definition: RPCCall_test.cpp:41
std::to_string
T to_string(T... args)
ripple::test::RPCCallTestData::bad_cast
@ bad_cast
Definition: RPCCall_test.cpp:40
ripple::test::rpcCallTestArray
static const RPCCallTestData rpcCallTestArray[]
Definition: RPCCall_test.cpp:69
ripple::test::RPCCall_test::testRPCCall
void testRPCCall()
Definition: RPCCall_test.cpp:6427
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test::RPCCallTestData::Exception
Exception
Definition: RPCCall_test.cpp:40
ripple::test::RPCCallTestData
Definition: RPCCall_test.cpp:32
ripple::cmdLineToJSONRPC
Json::Value cmdLineToJSONRPC(std::vector< std::string > const &args, beast::Journal j)
Given a rippled command line, return the corresponding JSON.
Definition: RPCCall.cpp:1493
ripple::test::RPCCallTestData::exp
char const *const exp
Definition: RPCCall_test.cpp:44
ripple::test::RPCCallTestData::description
char const *const description
Definition: RPCCall_test.cpp:34
std::vector::begin
T begin(T... args)
ripple::test::RPCCallTestData::RPCCallTestData
RPCCallTestData()=delete
Json::Reader::parse
bool parse(std::string const &document, Value &root)
Read a Value from a JSON document.
Definition: json_reader.cpp:74
ripple::RPC::apiMaximumSupportedVersion
constexpr unsigned int apiMaximumSupportedVersion
Definition: RPCHelpers.h:246
std::string::end
T end(T... args)
std::unique_ptr
STL class.
ripple::test::RPCCallTestData::line
const int line
Definition: RPCCall_test.cpp:35
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:117
ripple::test::RPCCall_test::run
void run() override
Definition: RPCCall_test.cpp:6492
Json::Value
Represents a JSON value.
Definition: json_value.h:145
ripple::test::updateAPIVersionString
std::string updateAPIVersionString(const char *const req)
Definition: RPCCall_test.cpp:6403
ripple::test::RPCCall_test
Definition: RPCCall_test.cpp:6423
initializer_list
ripple::test::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(DeliverMin, app, ripple)
Generated by   doxygen 1.8.17