Monero
Loading...
Searching...
No Matches
Macros | Functions | Variables
ringct.cpp File Reference
#include "gtest/gtest.h"
#include <cstdint>
#include <algorithm>
#include <sstream>
#include "ringct/rctTypes.h"
#include "ringct/rctSigs.h"
#include "ringct/rctOps.h"
#include "device/device.hpp"
#include "string_tools.h"
Include dependency graph for ringct.cpp:

Macros

#define NELTS(array)
#define TEST_rctSig_elements(name, op)
#define TEST_rctSig_elements_simple(name, op)

Functions

 TEST (ringct, Borromean)
 TEST (ringct, MG_sigs)
 TEST (ringct, CLSAG)
 TEST (ringct, range_proofs)
 TEST (ringct, range_proofs_with_fee)
 TEST (ringct, simple)
static rct::rctSig make_sample_rct_sig (int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], bool last_is_fee)
static rct::rctSig make_sample_simple_rct_sig (int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], uint64_t fee)
static bool range_proof_test (bool expected_valid, int n_inputs, const uint64_t input_amounts[], int n_outputs, const uint64_t output_amounts[], bool last_is_fee, bool simple)
 TEST (ringct, range_proofs_reject_empty_outs)
 TEST (ringct, range_proofs_reject_empty_outs_simple)
 TEST (ringct, range_proofs_reject_empty_ins)
 TEST (ringct, range_proofs_reject_empty_ins_simple)
 TEST (ringct, range_proofs_reject_all_empty)
 TEST (ringct, range_proofs_reject_all_empty_simple)
 TEST (ringct, range_proofs_accept_zero_empty)
 TEST (ringct, range_proofs_accept_zero_empty_simple)
 TEST (ringct, range_proofs_reject_empty_zero)
 TEST (ringct, range_proofs_reject_empty_zero_simple)
 TEST (ringct, range_proofs_accept_zero_zero)
 TEST (ringct, range_proofs_accept_zero_zero_simple)
 TEST (ringct, range_proofs_accept_zero_out_first)
 TEST (ringct, range_proofs_accept_zero_out_first_simple)
 TEST (ringct, range_proofs_accept_zero_out_last)
 TEST (ringct, range_proofs_accept_zero_out_last_simple)
 TEST (ringct, range_proofs_accept_zero_out_middle)
 TEST (ringct, range_proofs_accept_zero_out_middle_simple)
 TEST (ringct, range_proofs_accept_zero)
 TEST (ringct, range_proofs_accept_zero_in_first_simple)
 TEST (ringct, range_proofs_accept_zero_in_last_simple)
 TEST (ringct, range_proofs_accept_zero_in_middle_simple)
 TEST (ringct, range_proofs_reject_single_lower)
 TEST (ringct, range_proofs_reject_single_lower_simple)
 TEST (ringct, range_proofs_reject_single_higher)
 TEST (ringct, range_proofs_reject_single_higher_simple)
 TEST (ringct, range_proofs_reject_single_out_negative)
 TEST (ringct, range_proofs_reject_single_out_negative_simple)
 TEST (ringct, range_proofs_reject_out_negative_first)
 TEST (ringct, range_proofs_reject_out_negative_first_simple)
 TEST (ringct, range_proofs_reject_out_negative_last)
 TEST (ringct, range_proofs_reject_out_negative_last_simple)
 TEST (ringct, range_proofs_reject_out_negative_middle)
 TEST (ringct, range_proofs_reject_out_negative_middle_simple)
 TEST (ringct, range_proofs_reject_single_in_negative)
 TEST (ringct, range_proofs_reject_single_in_negative_simple)
 TEST (ringct, range_proofs_reject_in_negative_first)
 TEST (ringct, range_proofs_reject_in_negative_first_simple)
 TEST (ringct, range_proofs_reject_in_negative_last)
 TEST (ringct, range_proofs_reject_in_negative_last_simple)
 TEST (ringct, range_proofs_reject_in_negative_middle)
 TEST (ringct, range_proofs_reject_in_negative_middle_simple)
 TEST (ringct, range_proofs_reject_higher_list)
 TEST (ringct, range_proofs_reject_higher_list_simple)
 TEST (ringct, range_proofs_accept_1_to_1)
 TEST (ringct, range_proofs_accept_1_to_1_simple)
 TEST (ringct, range_proofs_accept_1_to_N)
 TEST (ringct, range_proofs_accept_1_to_N_simple)
 TEST (ringct, range_proofs_accept_N_to_1_simple)
 TEST (ringct, range_proofs_accept_N_to_N_simple)
 TEST (ringct, range_proofs_accept_very_long_simple)
 TEST (ringct, HPow2)
 TEST (ringct, d2h)
 TEST (ringct, d2b)
 TEST (ringct, prooveRange_is_non_deterministic)
 TEST (ringct, fee_0_valid)
 TEST (ringct, fee_0_valid_simple)
 TEST (ringct, fee_non_0_valid)
 TEST (ringct, fee_non_0_valid_simple)
 TEST (ringct, fee_non_0_invalid_higher)
 TEST (ringct, fee_non_0_invalid_higher_simple)
 TEST (ringct, fee_non_0_invalid_lower)
 TEST (ringct, fee_non_0_invalid_lower_simple)
 TEST (ringct, fee_burn_valid_one_out)
 TEST (ringct, fee_burn_valid_one_out_simple)
 TEST (ringct, fee_burn_valid_zero_out)
 TEST (ringct, fee_burn_valid_zero_out_simple)
static rctSig make_sig ()
 TEST_rctSig_elements (rangeSigs_empty, sig.p.rangeSigs.resize(0))
 TEST_rctSig_elements (rangeSigs_too_many, sig.p.rangeSigs.push_back(sig.p.rangeSigs.back()))
 TEST_rctSig_elements (rangeSigs_too_few, sig.p.rangeSigs.pop_back())
 TEST_rctSig_elements (mgSig_MG_empty, sig.p.MGs.resize(0))
 TEST_rctSig_elements (mgSig_ss_empty, sig.p.MGs[0].ss.resize(0))
 TEST_rctSig_elements (mgSig_ss_too_many, sig.p.MGs[0].ss.push_back(sig.p.MGs[0].ss.back()))
 TEST_rctSig_elements (mgSig_ss_too_few, sig.p.MGs[0].ss.pop_back())
 TEST_rctSig_elements (mgSig_ss0_empty, sig.p.MGs[0].ss[0].resize(0))
 TEST_rctSig_elements (mgSig_ss0_too_many, sig.p.MGs[0].ss[0].push_back(sig.p.MGs[0].ss[0].back()))
 TEST_rctSig_elements (mgSig_ss0_too_few, sig.p.MGs[0].ss[0].pop_back())
 TEST_rctSig_elements (mgSig_II_empty, sig.p.MGs[0].II.resize(0))
 TEST_rctSig_elements (mgSig_II_too_many, sig.p.MGs[0].II.push_back(sig.p.MGs[0].II.back()))
 TEST_rctSig_elements (mgSig_II_too_few, sig.p.MGs[0].II.pop_back())
 TEST_rctSig_elements (mixRing_empty, sig.mixRing.resize(0))
 TEST_rctSig_elements (mixRing_too_many, sig.mixRing.push_back(sig.mixRing.back()))
 TEST_rctSig_elements (mixRing_too_few, sig.mixRing.pop_back())
 TEST_rctSig_elements (mixRing0_empty, sig.mixRing[0].resize(0))
 TEST_rctSig_elements (mixRing0_too_many, sig.mixRing[0].push_back(sig.mixRing[0].back()))
 TEST_rctSig_elements (mixRing0_too_few, sig.mixRing[0].pop_back())
 TEST_rctSig_elements (ecdhInfo_empty, sig.ecdhInfo.resize(0))
 TEST_rctSig_elements (ecdhInfo_too_many, sig.ecdhInfo.push_back(sig.ecdhInfo.back()))
 TEST_rctSig_elements (ecdhInfo_too_few, sig.ecdhInfo.pop_back())
 TEST_rctSig_elements (outPk_empty, sig.outPk.resize(0))
 TEST_rctSig_elements (outPk_too_many, sig.outPk.push_back(sig.outPk.back()))
 TEST_rctSig_elements (outPk_too_few, sig.outPk.pop_back())
static rct::rctSig make_sig_simple ()
 TEST_rctSig_elements_simple (rangeSigs_empty, sig.p.rangeSigs.resize(0))
 TEST_rctSig_elements_simple (rangeSigs_too_many, sig.p.rangeSigs.push_back(sig.p.rangeSigs.back()))
 TEST_rctSig_elements_simple (rangeSigs_too_few, sig.p.rangeSigs.pop_back())
 TEST_rctSig_elements_simple (mgSig_empty, sig.p.MGs.resize(0))
 TEST_rctSig_elements_simple (mgSig_too_many, sig.p.MGs.push_back(sig.p.MGs.back()))
 TEST_rctSig_elements_simple (mgSig_too_few, sig.p.MGs.pop_back())
 TEST_rctSig_elements_simple (mgSig0_ss_empty, sig.p.MGs[0].ss.resize(0))
 TEST_rctSig_elements_simple (mgSig0_ss_too_many, sig.p.MGs[0].ss.push_back(sig.p.MGs[0].ss.back()))
 TEST_rctSig_elements_simple (mgSig0_ss_too_few, sig.p.MGs[0].ss.pop_back())
 TEST_rctSig_elements_simple (mgSig_ss0_empty, sig.p.MGs[0].ss[0].resize(0))
 TEST_rctSig_elements_simple (mgSig_ss0_too_many, sig.p.MGs[0].ss[0].push_back(sig.p.MGs[0].ss[0].back()))
 TEST_rctSig_elements_simple (mgSig_ss0_too_few, sig.p.MGs[0].ss[0].pop_back())
 TEST_rctSig_elements_simple (mgSig0_II_empty, sig.p.MGs[0].II.resize(0))
 TEST_rctSig_elements_simple (mgSig0_II_too_many, sig.p.MGs[0].II.push_back(sig.p.MGs[0].II.back()))
 TEST_rctSig_elements_simple (mgSig0_II_too_few, sig.p.MGs[0].II.pop_back())
 TEST_rctSig_elements_simple (mixRing_empty, sig.mixRing.resize(0))
 TEST_rctSig_elements_simple (mixRing_too_many, sig.mixRing.push_back(sig.mixRing.back()))
 TEST_rctSig_elements_simple (mixRing_too_few, sig.mixRing.pop_back())
 TEST_rctSig_elements_simple (mixRing0_empty, sig.mixRing[0].resize(0))
 TEST_rctSig_elements_simple (mixRing0_too_many, sig.mixRing[0].push_back(sig.mixRing[0].back()))
 TEST_rctSig_elements_simple (mixRing0_too_few, sig.mixRing[0].pop_back())
 TEST_rctSig_elements_simple (pseudoOuts_empty, sig.pseudoOuts.resize(0))
 TEST_rctSig_elements_simple (pseudoOuts_too_many, sig.pseudoOuts.push_back(sig.pseudoOuts.back()))
 TEST_rctSig_elements_simple (pseudoOuts_too_few, sig.pseudoOuts.pop_back())
 TEST_rctSig_elements_simple (ecdhInfo_empty, sig.ecdhInfo.resize(0))
 TEST_rctSig_elements_simple (ecdhInfo_too_many, sig.ecdhInfo.push_back(sig.ecdhInfo.back()))
 TEST_rctSig_elements_simple (ecdhInfo_too_few, sig.ecdhInfo.pop_back())
 TEST_rctSig_elements_simple (outPk_empty, sig.outPk.resize(0))
 TEST_rctSig_elements_simple (outPk_too_many, sig.outPk.push_back(sig.outPk.back()))
 TEST_rctSig_elements_simple (outPk_too_few, sig.outPk.pop_back())
 TEST (ringct, reject_gen_simple_ver_non_simple)
 TEST (ringct, reject_gen_non_simple_ver_simple)
 TEST (ringct, key_ostream)
 TEST (ringct, zeroCommmit)
static rct::key uncachedZeroCommit (uint64_t amount)
 TEST (ringct, zeroCommitCache)
 TEST (ringct, H)
 TEST (ringct, mul8)
 TEST (ringct, aggregated)

Variables

static const xmr_amount test_amounts [] ={0, 1, 2, 3, 4, 5, 10000, 10000000000000000000ull, 10203040506070809000ull, 123456789123456789}

Macro Definition Documentation

◆ NELTS

#define NELTS ( array)
Value:
(sizeof(array)/sizeof(array[0]))

◆ TEST_rctSig_elements

#define TEST_rctSig_elements ( name,
op )
Value:
TEST(ringct, rctSig_##name) \
{ \
rct::rctSig sig = make_sig(); \
ASSERT_TRUE(rct::verRct(sig)); \
op; \
ASSERT_FALSE(rct::verRct(sig)); \
}
TEST
#define TEST(test_case_name, test_name)
Definition gtest.h:2187
rct::verRct
bool verRct(const rctSig &rv, bool semantics)
Definition rctSigs.cpp:1318
name
const char * name
Definition options.c:30
make_sig
static rctSig make_sig()
Definition ringct.cpp:1087
rct::rctSig
Definition rctTypes.h:613

◆ TEST_rctSig_elements_simple

#define TEST_rctSig_elements_simple ( name,
op )
Value:
TEST(ringct, rctSig_##name##_simple) \
{ \
rct::rctSig sig = make_sig_simple(); \
ASSERT_TRUE(rct::verRctSimple(sig)); \
op; \
ASSERT_FALSE(rct::verRctSimple(sig)); \
}
rct::verRctSimple
static bool verRctSimple(const rctSig &rv)
Definition rctSigs.h:135
make_sig_simple
static rct::rctSig make_sig_simple()
Definition ringct.cpp:1130

Function Documentation

◆ make_sample_rct_sig()

rct::rctSig make_sample_rct_sig ( int n_inputs,
const uint64_t input_amounts[],
int n_outputs,
const uint64_t output_amounts[],
bool last_is_fee )
static

◆ make_sample_simple_rct_sig()

rct::rctSig make_sample_simple_rct_sig ( int n_inputs,
const uint64_t input_amounts[],
int n_outputs,
const uint64_t output_amounts[],
uint64_t fee )
static

◆ make_sig()

rctSig make_sig ( )
static

◆ make_sig_simple()

rct::rctSig make_sig_simple ( )
static

◆ range_proof_test()

bool range_proof_test ( bool expected_valid,
int n_inputs,
const uint64_t input_amounts[],
int n_outputs,
const uint64_t output_amounts[],
bool last_is_fee,
bool simple )
static

◆ TEST() [1/81]

TEST ( ringct ,
aggregated  )

◆ TEST() [2/81]

TEST ( ringct ,
Borromean  )

◆ TEST() [3/81]

TEST ( ringct ,
CLSAG  )

◆ TEST() [4/81]

TEST ( ringct ,
d2b  )

◆ TEST() [5/81]

TEST ( ringct ,
d2h  )

◆ TEST() [6/81]

TEST ( ringct ,
fee_0_valid  )

◆ TEST() [7/81]

TEST ( ringct ,
fee_0_valid_simple  )

◆ TEST() [8/81]

TEST ( ringct ,
fee_burn_valid_one_out  )

◆ TEST() [9/81]

TEST ( ringct ,
fee_burn_valid_one_out_simple  )

◆ TEST() [10/81]

TEST ( ringct ,
fee_burn_valid_zero_out  )

◆ TEST() [11/81]

TEST ( ringct ,
fee_burn_valid_zero_out_simple  )

◆ TEST() [12/81]

TEST ( ringct ,
fee_non_0_invalid_higher  )

◆ TEST() [13/81]

TEST ( ringct ,
fee_non_0_invalid_higher_simple  )

◆ TEST() [14/81]

TEST ( ringct ,
fee_non_0_invalid_lower  )

◆ TEST() [15/81]

TEST ( ringct ,
fee_non_0_invalid_lower_simple  )

◆ TEST() [16/81]

TEST ( ringct ,
fee_non_0_valid  )

◆ TEST() [17/81]

TEST ( ringct ,
fee_non_0_valid_simple  )

◆ TEST() [18/81]

TEST ( ringct ,
H  )

◆ TEST() [19/81]

TEST ( ringct ,
HPow2  )

◆ TEST() [20/81]

TEST ( ringct ,
key_ostream  )

◆ TEST() [21/81]

TEST ( ringct ,
MG_sigs  )

◆ TEST() [22/81]

TEST ( ringct ,
mul8  )

◆ TEST() [23/81]

TEST ( ringct ,
prooveRange_is_non_deterministic  )

◆ TEST() [24/81]

TEST ( ringct ,
range_proofs  )

◆ TEST() [25/81]

TEST ( ringct ,
range_proofs_accept_1_to_1  )

◆ TEST() [26/81]

TEST ( ringct ,
range_proofs_accept_1_to_1_simple  )

◆ TEST() [27/81]

TEST ( ringct ,
range_proofs_accept_1_to_N  )

◆ TEST() [28/81]

TEST ( ringct ,
range_proofs_accept_1_to_N_simple  )

◆ TEST() [29/81]

TEST ( ringct ,
range_proofs_accept_N_to_1_simple  )

◆ TEST() [30/81]

TEST ( ringct ,
range_proofs_accept_N_to_N_simple  )

◆ TEST() [31/81]

TEST ( ringct ,
range_proofs_accept_very_long_simple  )

◆ TEST() [32/81]

TEST ( ringct ,
range_proofs_accept_zero  )

◆ TEST() [33/81]

TEST ( ringct ,
range_proofs_accept_zero_empty  )

◆ TEST() [34/81]

TEST ( ringct ,
range_proofs_accept_zero_empty_simple  )

◆ TEST() [35/81]

TEST ( ringct ,
range_proofs_accept_zero_in_first_simple  )

◆ TEST() [36/81]

TEST ( ringct ,
range_proofs_accept_zero_in_last_simple  )

◆ TEST() [37/81]

TEST ( ringct ,
range_proofs_accept_zero_in_middle_simple  )

◆ TEST() [38/81]

TEST ( ringct ,
range_proofs_accept_zero_out_first  )

◆ TEST() [39/81]

TEST ( ringct ,
range_proofs_accept_zero_out_first_simple  )

◆ TEST() [40/81]

TEST ( ringct ,
range_proofs_accept_zero_out_last  )

◆ TEST() [41/81]

TEST ( ringct ,
range_proofs_accept_zero_out_last_simple  )

◆ TEST() [42/81]

TEST ( ringct ,
range_proofs_accept_zero_out_middle  )

◆ TEST() [43/81]

TEST ( ringct ,
range_proofs_accept_zero_out_middle_simple  )

◆ TEST() [44/81]

TEST ( ringct ,
range_proofs_accept_zero_zero  )

◆ TEST() [45/81]

TEST ( ringct ,
range_proofs_accept_zero_zero_simple  )

◆ TEST() [46/81]

TEST ( ringct ,
range_proofs_reject_all_empty  )

◆ TEST() [47/81]

TEST ( ringct ,
range_proofs_reject_all_empty_simple  )

◆ TEST() [48/81]

TEST ( ringct ,
range_proofs_reject_empty_ins  )

◆ TEST() [49/81]

TEST ( ringct ,
range_proofs_reject_empty_ins_simple  )

◆ TEST() [50/81]

TEST ( ringct ,
range_proofs_reject_empty_outs  )

◆ TEST() [51/81]

TEST ( ringct ,
range_proofs_reject_empty_outs_simple  )

◆ TEST() [52/81]

TEST ( ringct ,
range_proofs_reject_empty_zero  )

◆ TEST() [53/81]

TEST ( ringct ,
range_proofs_reject_empty_zero_simple  )

◆ TEST() [54/81]

TEST ( ringct ,
range_proofs_reject_higher_list  )

◆ TEST() [55/81]

TEST ( ringct ,
range_proofs_reject_higher_list_simple  )

◆ TEST() [56/81]

TEST ( ringct ,
range_proofs_reject_in_negative_first  )

◆ TEST() [57/81]

TEST ( ringct ,
range_proofs_reject_in_negative_first_simple  )

◆ TEST() [58/81]

TEST ( ringct ,
range_proofs_reject_in_negative_last  )

◆ TEST() [59/81]

TEST ( ringct ,
range_proofs_reject_in_negative_last_simple  )

◆ TEST() [60/81]

TEST ( ringct ,
range_proofs_reject_in_negative_middle  )

◆ TEST() [61/81]

TEST ( ringct ,
range_proofs_reject_in_negative_middle_simple  )

◆ TEST() [62/81]

TEST ( ringct ,
range_proofs_reject_out_negative_first  )

◆ TEST() [63/81]

TEST ( ringct ,
range_proofs_reject_out_negative_first_simple  )

◆ TEST() [64/81]

TEST ( ringct ,
range_proofs_reject_out_negative_last  )

◆ TEST() [65/81]

TEST ( ringct ,
range_proofs_reject_out_negative_last_simple  )

◆ TEST() [66/81]

TEST ( ringct ,
range_proofs_reject_out_negative_middle  )

◆ TEST() [67/81]

TEST ( ringct ,
range_proofs_reject_out_negative_middle_simple  )

◆ TEST() [68/81]

TEST ( ringct ,
range_proofs_reject_single_higher  )

◆ TEST() [69/81]

TEST ( ringct ,
range_proofs_reject_single_higher_simple  )

◆ TEST() [70/81]

TEST ( ringct ,
range_proofs_reject_single_in_negative  )

◆ TEST() [71/81]

TEST ( ringct ,
range_proofs_reject_single_in_negative_simple  )

◆ TEST() [72/81]

TEST ( ringct ,
range_proofs_reject_single_lower  )

◆ TEST() [73/81]

TEST ( ringct ,
range_proofs_reject_single_lower_simple  )

◆ TEST() [74/81]

TEST ( ringct ,
range_proofs_reject_single_out_negative  )

◆ TEST() [75/81]

TEST ( ringct ,
range_proofs_reject_single_out_negative_simple  )

◆ TEST() [76/81]

TEST ( ringct ,
range_proofs_with_fee  )

◆ TEST() [77/81]

TEST ( ringct ,
reject_gen_non_simple_ver_simple  )

◆ TEST() [78/81]

TEST ( ringct ,
reject_gen_simple_ver_non_simple  )

◆ TEST() [79/81]

TEST ( ringct ,
simple  )

◆ TEST() [80/81]

TEST ( ringct ,
zeroCommitCache  )

◆ TEST() [81/81]

TEST ( ringct ,
zeroCommmit  )

◆ TEST_rctSig_elements() [1/25]

TEST_rctSig_elements ( ecdhInfo_empty ,
sig.ecdhInfo. resize0 )

◆ TEST_rctSig_elements() [2/25]

TEST_rctSig_elements ( ecdhInfo_too_few ,
sig.ecdhInfo. pop_back() )

◆ TEST_rctSig_elements() [3/25]

TEST_rctSig_elements ( ecdhInfo_too_many ,
sig.ecdhInfo. push_backsig.ecdhInfo.back() )

◆ TEST_rctSig_elements() [4/25]

TEST_rctSig_elements ( mgSig_II_empty ,
sig.p.MGs.II. resize(0)[0] )

◆ TEST_rctSig_elements() [5/25]

TEST_rctSig_elements ( mgSig_II_too_few ,
sig.p.MGs.II. pop_back()[0] )

◆ TEST_rctSig_elements() [6/25]

TEST_rctSig_elements ( mgSig_II_too_many ,
sig.p.MGs.II. push_back(sig.p.MGs[0].II.back())[0] )

◆ TEST_rctSig_elements() [7/25]

TEST_rctSig_elements ( mgSig_MG_empty ,
sig.p.MGs. resize0 )

◆ TEST_rctSig_elements() [8/25]

TEST_rctSig_elements ( mgSig_ss0_empty ,
sig.p.MGs.ss. resize(0)[0][0] )

◆ TEST_rctSig_elements() [9/25]

TEST_rctSig_elements ( mgSig_ss0_too_few ,
sig.p.MGs.ss. pop_back()[0][0] )

◆ TEST_rctSig_elements() [10/25]

TEST_rctSig_elements ( mgSig_ss0_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss[0].back())[0][0] )

◆ TEST_rctSig_elements() [11/25]

TEST_rctSig_elements ( mgSig_ss_empty ,
sig.p.MGs.ss. resize(0)[0] )

◆ TEST_rctSig_elements() [12/25]

TEST_rctSig_elements ( mgSig_ss_too_few ,
sig.p.MGs.ss. pop_back()[0] )

◆ TEST_rctSig_elements() [13/25]

TEST_rctSig_elements ( mgSig_ss_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss.back())[0] )

◆ TEST_rctSig_elements() [14/25]

TEST_rctSig_elements ( mixRing0_empty ,
sig.mixRing. resize(0)[0] )

◆ TEST_rctSig_elements() [15/25]

TEST_rctSig_elements ( mixRing0_too_few ,
sig.mixRing. pop_back()[0] )

◆ TEST_rctSig_elements() [16/25]

TEST_rctSig_elements ( mixRing0_too_many ,
sig.mixRing. push_back(sig.mixRing[0].back())[0] )

◆ TEST_rctSig_elements() [17/25]

TEST_rctSig_elements ( mixRing_empty ,
sig.mixRing. resize0 )

◆ TEST_rctSig_elements() [18/25]

TEST_rctSig_elements ( mixRing_too_few ,
sig.mixRing. pop_back() )

◆ TEST_rctSig_elements() [19/25]

TEST_rctSig_elements ( mixRing_too_many ,
sig.mixRing. push_backsig.mixRing.back() )

◆ TEST_rctSig_elements() [20/25]

TEST_rctSig_elements ( outPk_empty ,
sig.outPk. resize0 )

◆ TEST_rctSig_elements() [21/25]

TEST_rctSig_elements ( outPk_too_few ,
sig.outPk. pop_back() )

◆ TEST_rctSig_elements() [22/25]

TEST_rctSig_elements ( outPk_too_many ,
sig.outPk. push_backsig.outPk.back() )

◆ TEST_rctSig_elements() [23/25]

TEST_rctSig_elements ( rangeSigs_empty ,
sig.p.rangeSigs. resize0 )

◆ TEST_rctSig_elements() [24/25]

TEST_rctSig_elements ( rangeSigs_too_few ,
sig.p.rangeSigs. pop_back() )

◆ TEST_rctSig_elements() [25/25]

TEST_rctSig_elements ( rangeSigs_too_many ,
sig.p.rangeSigs. push_backsig.p.rangeSigs.back() )

◆ TEST_rctSig_elements_simple() [1/30]

TEST_rctSig_elements_simple ( ecdhInfo_empty ,
sig.ecdhInfo. resize0 )

◆ TEST_rctSig_elements_simple() [2/30]

TEST_rctSig_elements_simple ( ecdhInfo_too_few ,
sig.ecdhInfo. pop_back() )

◆ TEST_rctSig_elements_simple() [3/30]

TEST_rctSig_elements_simple ( ecdhInfo_too_many ,
sig.ecdhInfo. push_backsig.ecdhInfo.back() )

◆ TEST_rctSig_elements_simple() [4/30]

TEST_rctSig_elements_simple ( mgSig0_II_empty ,
sig.p.MGs.II. resize(0)[0] )

◆ TEST_rctSig_elements_simple() [5/30]

TEST_rctSig_elements_simple ( mgSig0_II_too_few ,
sig.p.MGs.II. pop_back()[0] )

◆ TEST_rctSig_elements_simple() [6/30]

TEST_rctSig_elements_simple ( mgSig0_II_too_many ,
sig.p.MGs.II. push_back(sig.p.MGs[0].II.back())[0] )

◆ TEST_rctSig_elements_simple() [7/30]

TEST_rctSig_elements_simple ( mgSig0_ss_empty ,
sig.p.MGs.ss. resize(0)[0] )

◆ TEST_rctSig_elements_simple() [8/30]

TEST_rctSig_elements_simple ( mgSig0_ss_too_few ,
sig.p.MGs.ss. pop_back()[0] )

◆ TEST_rctSig_elements_simple() [9/30]

TEST_rctSig_elements_simple ( mgSig0_ss_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss.back())[0] )

◆ TEST_rctSig_elements_simple() [10/30]

TEST_rctSig_elements_simple ( mgSig_empty ,
sig.p.MGs. resize0 )

◆ TEST_rctSig_elements_simple() [11/30]

TEST_rctSig_elements_simple ( mgSig_ss0_empty ,
sig.p.MGs.ss. resize(0)[0][0] )

◆ TEST_rctSig_elements_simple() [12/30]

TEST_rctSig_elements_simple ( mgSig_ss0_too_few ,
sig.p.MGs.ss. pop_back()[0][0] )

◆ TEST_rctSig_elements_simple() [13/30]

TEST_rctSig_elements_simple ( mgSig_ss0_too_many ,
sig.p.MGs.ss. push_back(sig.p.MGs[0].ss[0].back())[0][0] )

◆ TEST_rctSig_elements_simple() [14/30]

TEST_rctSig_elements_simple ( mgSig_too_few ,
sig.p.MGs. pop_back() )

◆ TEST_rctSig_elements_simple() [15/30]

TEST_rctSig_elements_simple ( mgSig_too_many ,
sig.p.MGs. push_backsig.p.MGs.back() )

◆ TEST_rctSig_elements_simple() [16/30]

TEST_rctSig_elements_simple ( mixRing0_empty ,
sig.mixRing. resize(0)[0] )

◆ TEST_rctSig_elements_simple() [17/30]

TEST_rctSig_elements_simple ( mixRing0_too_few ,
sig.mixRing. pop_back()[0] )

◆ TEST_rctSig_elements_simple() [18/30]

TEST_rctSig_elements_simple ( mixRing0_too_many ,
sig.mixRing. push_back(sig.mixRing[0].back())[0] )

◆ TEST_rctSig_elements_simple() [19/30]

TEST_rctSig_elements_simple ( mixRing_empty ,
sig.mixRing. resize0 )

◆ TEST_rctSig_elements_simple() [20/30]

TEST_rctSig_elements_simple ( mixRing_too_few ,
sig.mixRing. pop_back() )

◆ TEST_rctSig_elements_simple() [21/30]

TEST_rctSig_elements_simple ( mixRing_too_many ,
sig.mixRing. push_backsig.mixRing.back() )

◆ TEST_rctSig_elements_simple() [22/30]

TEST_rctSig_elements_simple ( outPk_empty ,
sig.outPk. resize0 )

◆ TEST_rctSig_elements_simple() [23/30]

TEST_rctSig_elements_simple ( outPk_too_few ,
sig.outPk. pop_back() )

◆ TEST_rctSig_elements_simple() [24/30]

TEST_rctSig_elements_simple ( outPk_too_many ,
sig.outPk. push_backsig.outPk.back() )

◆ TEST_rctSig_elements_simple() [25/30]

TEST_rctSig_elements_simple ( pseudoOuts_empty ,
sig.pseudoOuts. resize0 )

◆ TEST_rctSig_elements_simple() [26/30]

TEST_rctSig_elements_simple ( pseudoOuts_too_few ,
sig.pseudoOuts. pop_back() )

◆ TEST_rctSig_elements_simple() [27/30]

TEST_rctSig_elements_simple ( pseudoOuts_too_many ,
sig.pseudoOuts. push_backsig.pseudoOuts.back() )

◆ TEST_rctSig_elements_simple() [28/30]

TEST_rctSig_elements_simple ( rangeSigs_empty ,
sig.p.rangeSigs. resize0 )

◆ TEST_rctSig_elements_simple() [29/30]

TEST_rctSig_elements_simple ( rangeSigs_too_few ,
sig.p.rangeSigs. pop_back() )

◆ TEST_rctSig_elements_simple() [30/30]

TEST_rctSig_elements_simple ( rangeSigs_too_many ,
sig.p.rangeSigs. push_backsig.p.rangeSigs.back() )

◆ uncachedZeroCommit()

rct::key uncachedZeroCommit ( uint64_t amount)
static

Variable Documentation

◆ test_amounts

const xmr_amount test_amounts[] ={0, 1, 2, 3, 4, 5, 10000, 10000000000000000000ull, 10203040506070809000ull, 123456789123456789}
static
Generated on for Monero by doxygen 1.16.1