tor-commits November 2014

tor-commits@lists.torproject.org

24 participants
954 discussions

[tor/master] Fix a likely bug found by coverity in test_scheduler.c.
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 49976fabc4457713347fe6d0c8e16939de852393 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 23:21:46 2014 -0500 Fix a likely bug found by coverity in test_scheduler.c. Andrea, do you agree with this? This is CID 1256186 --- src/test/test_scheduler.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/test_scheduler.c b/src/test/test_scheduler.c index da5c4e8..d031214 100644 --- a/src/test/test_scheduler.c +++ b/src/test/test_scheduler.c @@ -258,7 +258,7 @@ circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, else if (cmux_1 == mock_ccm_tgt_2 && cmux_2 == mock_ccm_tgt_1) { result = 1; } else { - if (cmux_1 == mock_ccm_tgt_1 || cmux_1 == mock_ccm_tgt_1) result = -1; + if (cmux_1 == mock_ccm_tgt_1 || cmux_1 == mock_ccm_tgt_2) result = -1; else if (cmux_2 == mock_ccm_tgt_1 || cmux_2 == mock_ccm_tgt_2) { result = 1; } else {

1 0

[tor/master] Tweak global_scheduler changes file
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 95ead313490accfb9ec43630a702b6d735dd34fb Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 23:05:21 2014 -0500 Tweak global_scheduler changes file --- changes/global_scheduler | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/changes/global_scheduler b/changes/global_scheduler index d0b8305..df3b464 100644 --- a/changes/global_scheduler +++ b/changes/global_scheduler @@ -1,4 +1,12 @@ - o Major changes: + o Major features (relay, infrastructure): - Implement a new inter-cmux comparison API, a global high/low watermark mechanism and a global scheduler loop for transmission prioritization - across all channels as well as among circuits on one channel. + across all channels as well as among circuits on one channel. This + schedule is currently tuned to (tolerantly) avoid making changes + in the current network performance, but it should form the basis + major circuit performance increases. Code by Andrea; implements + ticket 9262. + + o Testing: + - New tests for many parts of channel, relay, and circuit mux + functionality. Code by Andrea; part of 9262.

1 0

[tor/master] Make channel_flush_some_cells() mockable
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 99d312c2937c0289eec047a70f626e3976a25895 Author: Andrea Shepard <andrea(a)torproject.org> Date: Mon Feb 3 12:52:28 2014 -0800 Make channel_flush_some_cells() mockable --- src/or/channel.c | 4 ++-- src/or/channel.h | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/or/channel.c b/src/or/channel.c index ec44cce..edeee69 100644 --- a/src/or/channel.c +++ b/src/or/channel.c @@ -2197,8 +2197,8 @@ channel_listener_change_state(channel_listener_t *chan_l, #define MAX_CELLS_TO_GET_FROM_CIRCUITS_FOR_UNLIMITED 256 -ssize_t -channel_flush_some_cells(channel_t *chan, ssize_t num_cells) +MOCK_IMPL(ssize_t, +channel_flush_some_cells, (channel_t *chan, ssize_t num_cells)) { unsigned int unlimited = 0; ssize_t flushed = 0; diff --git a/src/or/channel.h b/src/or/channel.h index 07a66eb..dd0ca36 100644 --- a/src/or/channel.h +++ b/src/or/channel.h @@ -455,7 +455,8 @@ void channel_queue_var_cell(channel_t *chan, var_cell_t *var_cell); void channel_flush_cells(channel_t *chan); /* Request from lower layer for more cells if available */ -ssize_t channel_flush_some_cells(channel_t *chan, ssize_t num_cells); +MOCK_DECL(ssize_t, channel_flush_some_cells, + (channel_t *chan, ssize_t num_cells)); /* Query if data available on this channel */ int channel_more_to_flush(channel_t *chan);

1 0

[tor/master] Merge remote-tracking branch 'andrea/cmux_refactor_configurable_threshold'
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit a28df3fb6713043e801fb5fcf5019fc0539b5066 Merge: 3d2366c 12b6c7d Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 22:39:46 2014 -0500 Merge remote-tracking branch 'andrea/cmux_refactor_configurable_threshold' Conflicts: src/or/or.h src/test/Makefile.nmake changes/global_scheduler | 4 + scripts/maint/checkSpace.pl | 3 +- src/common/compat_libevent.c | 4 +- src/common/compat_libevent.h | 2 +- src/common/torlog.h | 4 +- src/or/Makefile.nmake | 1 + src/or/buffers.c | 4 +- src/or/buffers.h | 2 +- src/or/channel.c | 477 ++++++++++-- src/or/channel.h | 87 ++- src/or/channeltls.c | 141 ++-- src/or/channeltls.h | 2 - src/or/circuitbuild.c | 1 + src/or/circuitlist.c | 4 +- src/or/circuitlist.h | 3 +- src/or/circuitmux.c | 56 +- src/or/circuitmux.h | 12 +- src/or/circuitmux_ewma.c | 58 +- src/or/config.c | 35 +- src/or/config.h | 2 +- src/or/connection.c | 2 + src/or/connection_or.c | 67 +- src/or/connection_or.h | 8 +- src/or/include.am | 2 + src/or/main.c | 2 + src/or/or.h | 30 + src/or/relay.c | 15 +- src/or/relay.h | 3 +- src/or/scheduler.c | 708 ++++++++++++++++++ src/or/scheduler.h | 50 ++ src/test/Makefile.nmake | 7 +- src/test/fakechans.h | 25 + src/test/include.am | 4 + src/test/test.c | 9 + src/test/test_channel.c | 1669 ++++++++++++++++++++++++++++++++++++++++++ src/test/test_channeltls.c | 332 +++++++++ src/test/test_circuitmux.c | 3 + src/test/test_relay.c | 134 ++++ src/test/test_scheduler.c | 763 +++++++++++++++++++ 39 files changed, 4558 insertions(+), 177 deletions(-) diff --cc src/or/include.am index 0f53f00,b2b9406..643f7ce --- a/src/or/include.am +++ b/src/or/include.am @@@ -74,11 -80,12 +74,12 @@@ LIBTOR_A_SOURCES = src/or/routerlist.c \ src/or/routerparse.c \ src/or/routerset.c \ + src/or/scheduler.c \ src/or/statefile.c \ src/or/status.c \ + src/or/onion_ntor.c \ $(evdns_source) \ $(tor_platform_source) \ - $(onion_ntor_source) \ src/or/config_codedigest.c src_or_libtor_a_SOURCES = $(LIBTOR_A_SOURCES) diff --cc src/or/or.h index bff7267,25df54a..ccb29ee --- a/src/or/or.h +++ b/src/or/or.h @@@ -4230,6 -4227,21 +4248,18 @@@ typedef struct /** How long (seconds) do we keep a guard before picking a new one? */ int GuardLifetime; - /** Should we send the timestamps that pre-023 hidden services want? */ - int Support022HiddenServices; - + /** Low-water mark for global scheduler - start sending when estimated + * queued size falls below this threshold. + */ + uint32_t SchedulerLowWaterMark; + /** High-water mark for global scheduler - stop sending when estimated + * queued size exceeds this threshold. + */ + uint32_t SchedulerHighWaterMark; + /** Flush size for global scheduler - flush this many cells at a time + * when sending. + */ + unsigned int SchedulerMaxFlushCells; } or_options_t; /** Persistent state for an onion router, as saved to disk. */ diff --cc src/test/Makefile.nmake index f6ee7f3,e2cf538..0435617 --- a/src/test/Makefile.nmake +++ b/src/test/Makefile.nmake @@@ -11,11 -11,11 +11,12 @@@ LIBS = ..\..\..\build-alpha\lib\libeven ws2_32.lib advapi32.lib shell32.lib \ crypt32.lib gdi32.lib user32.lib - TEST_OBJECTS = test.obj test_addr.obj test_containers.obj \ + TEST_OBJECTS = test.obj test_addr.obj test_channel.obj test_channeltls.obj \ - test_containers.obj test_controller_events.obj test_crypto.obj \ - test_data.obj test_dir.obj test_microdesc.obj test_pt.obj test_util.obj \ - test_config.obj test_cell_formats.obj test_relay.obj test_replay.obj \ ++ test_containers.obj \ + test_controller_events.obj test_crypto.obj test_data.obj test_dir.obj \ + test_checkdir.obj test_microdesc.obj test_pt.obj test_util.obj test_config.obj \ - test_cell_formats.obj test_replay.obj test_introduce.obj tinytest.obj \ - test_hs.obj ++ test_cell_formats.obj test_relay.obj test_replay.obj \ + test_scheduler.obj test_introduce.obj test_hs.obj tinytest.obj tinytest.obj: ..\ext\tinytest.c $(CC) $(CFLAGS) /D snprintf=_snprintf /c ..\ext\tinytest.c

1 0

[tor/master] Update test_channel.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 2d171c108191799b63737768bbad104ced0ac4cd Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 07:11:24 2014 -0700 Update test_channel.c for recent test suite changes and --enable-mempools support --- src/test/test_channel.c | 427 +++++++++++++++++++++++++---------------------- 1 file changed, 224 insertions(+), 203 deletions(-) diff --git a/src/test/test_channel.c b/src/test/test_channel.c index 9ad271d..49590f5 100644 --- a/src/test/test_channel.c +++ b/src/test/test_channel.c @@ -86,7 +86,7 @@ channel_note_destroy_not_pending_mock(channel_t *ch, static const char * chan_test_describe_transport(channel_t *ch) { - test_assert(ch != NULL); + tt_assert(ch != NULL); done: return "Fake channel for unit tests"; @@ -100,7 +100,7 @@ chan_test_describe_transport(channel_t *ch) static void chan_test_channel_dump_statistics_mock(channel_t *chan, int severity) { - test_assert(chan != NULL); + tt_assert(chan != NULL); (void)severity; @@ -125,7 +125,7 @@ chan_test_channel_flush_from_first_active_circuit_mock(channel_t *chan, int result = 0, c = 0; packed_cell_t *cell = NULL; - test_assert(chan != NULL); + tt_assert(chan != NULL); if (test_target_cmux != NULL && test_target_cmux == chan->cmux) { while (c <= max && test_cmux_cells > 0) { @@ -154,7 +154,7 @@ chan_test_circuitmux_num_cells_mock(circuitmux_t *cmux) { unsigned int result = 0; - test_assert(cmux != NULL); + tt_assert(cmux != NULL); if (cmux != NULL) { if (cmux == test_target_cmux) { result = test_cmux_cells; @@ -176,8 +176,8 @@ static void chan_test_cell_handler(channel_t *ch, cell_t *cell) { - test_assert(ch); - test_assert(cell); + tt_assert(ch); + tt_assert(cell); tor_free(cell); ++test_chan_fixed_cells_recved; @@ -193,7 +193,7 @@ chan_test_cell_handler(channel_t *ch, static void chan_test_dumpstats(channel_t *ch, int severity) { - test_assert(ch != NULL); + tt_assert(ch != NULL); (void)severity; @@ -211,8 +211,8 @@ static void chan_test_var_cell_handler(channel_t *ch, var_cell_t *var_cell) { - test_assert(ch); - test_assert(var_cell); + tt_assert(ch); + tt_assert(var_cell); tor_free(var_cell); ++test_chan_var_cells_recved; @@ -224,7 +224,7 @@ chan_test_var_cell_handler(channel_t *ch, static void chan_test_close(channel_t *ch) { - test_assert(ch); + tt_assert(ch); done: return; @@ -237,8 +237,8 @@ chan_test_close(channel_t *ch) static void chan_test_error(channel_t *ch) { - test_assert(ch); - test_assert(!(ch->state == CHANNEL_STATE_CLOSING || + tt_assert(ch); + tt_assert(!(ch->state == CHANNEL_STATE_CLOSING || ch->state == CHANNEL_STATE_ERROR || ch->state == CHANNEL_STATE_CLOSED)); @@ -255,8 +255,8 @@ chan_test_error(channel_t *ch) static void chan_test_finish_close(channel_t *ch) { - test_assert(ch); - test_assert(ch->state == CHANNEL_STATE_CLOSING); + tt_assert(ch); + tt_assert(ch->state == CHANNEL_STATE_CLOSING); channel_closed(ch); @@ -267,8 +267,8 @@ chan_test_finish_close(channel_t *ch) static const char * chan_test_get_remote_descr(channel_t *ch, int flags) { - test_assert(ch); - test_eq(flags & ~(GRD_FLAG_ORIGINAL | GRD_FLAG_ADDR_ONLY), 0); + tt_assert(ch); + tt_int_op(flags & ~(GRD_FLAG_ORIGINAL | GRD_FLAG_ADDR_ONLY), ==, 0); done: return "Fake channel for unit tests; no real endpoint"; @@ -277,7 +277,7 @@ chan_test_get_remote_descr(channel_t *ch, int flags) static double chan_test_get_overhead_estimate(channel_t *ch) { - test_assert(ch); + tt_assert(ch); done: return test_overhead_estimate; @@ -286,8 +286,8 @@ chan_test_get_overhead_estimate(channel_t *ch) static int chan_test_is_canonical(channel_t *ch, int req) { - test_assert(ch != NULL); - test_assert(req == 0 || req == 1); + tt_assert(ch != NULL); + tt_assert(req == 0 || req == 1); done: /* Fake channels are always canonical */ @@ -297,7 +297,7 @@ chan_test_is_canonical(channel_t *ch, int req) static size_t chan_test_num_bytes_queued(channel_t *ch) { - test_assert(ch); + tt_assert(ch); done: return 0; @@ -306,7 +306,7 @@ chan_test_num_bytes_queued(channel_t *ch) static int chan_test_num_cells_writeable(channel_t *ch) { - test_assert(ch); + tt_assert(ch); done: return 32; @@ -317,8 +317,8 @@ chan_test_write_cell(channel_t *ch, cell_t *cell) { int rv = 0; - test_assert(ch); - test_assert(cell); + tt_assert(ch); + tt_assert(cell); if (test_chan_accept_cells) { /* Free the cell and bump the counter */ @@ -338,8 +338,8 @@ chan_test_write_packed_cell(channel_t *ch, { int rv = 0; - test_assert(ch); - test_assert(packed_cell); + tt_assert(ch); + tt_assert(packed_cell); if (test_chan_accept_cells) { /* Free the cell and bump the counter */ @@ -358,8 +358,8 @@ chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell) { int rv = 0; - test_assert(ch); - test_assert(var_cell); + tt_assert(ch); + tt_assert(var_cell); if (test_chan_accept_cells) { /* Free the cell and bump the counter */ @@ -380,7 +380,7 @@ chan_test_write_var_cell(channel_t *ch, var_cell_t *var_cell) void make_fake_cell(cell_t *c) { - test_assert(c != NULL); + tt_assert(c != NULL); c->circ_id = 1; c->command = CELL_RELAY; @@ -397,7 +397,7 @@ make_fake_cell(cell_t *c) void make_fake_var_cell(var_cell_t *c) { - test_assert(c != NULL); + tt_assert(c != NULL); c->circ_id = 1; c->command = CELL_VERSIONS; @@ -513,12 +513,12 @@ test_channel_dumpstats(void *arg) /* Set up a new fake channel */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->cmux = circuitmux_alloc(); /* Try to register it */ channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Set up mock */ dump_statistics_mock_target = ch; @@ -530,24 +530,24 @@ test_channel_dumpstats(void *arg) channel_dumpstats(LOG_DEBUG); /* Assert that we hit the mock */ - test_eq(dump_statistics_mock_matches, 1); + tt_int_op(dump_statistics_mock_matches, ==, 1); /* Close the channel */ channel_mark_for_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSED); /* Try again and hit the finished channel */ channel_dumpstats(LOG_DEBUG); - test_eq(dump_statistics_mock_matches, 2); + tt_int_op(dump_statistics_mock_matches, ==, 2); channel_run_cleanup(); ch = NULL; /* Now we should hit nothing */ channel_dumpstats(LOG_DEBUG); - test_eq(dump_statistics_mock_matches, 2); + tt_int_op(dump_statistics_mock_matches, ==, 2); /* Unmock */ UNMOCK(channel_dump_statistics); @@ -556,14 +556,14 @@ test_channel_dumpstats(void *arg) /* Now make another channel */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->cmux = circuitmux_alloc(); channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Lie about its age so dumpstats gets coverage for rate calculations */ ch->timestamp_created = time(NULL) - 30; - test_assert(ch->timestamp_created > 0); - test_assert(time(NULL) > ch->timestamp_created); + tt_assert(ch->timestamp_created > 0); + tt_assert(time(NULL) > ch->timestamp_created); /* Put cells through it both ways to make the counters non-zero */ cell = tor_malloc_zero(sizeof(*cell)); @@ -572,24 +572,24 @@ test_channel_dumpstats(void *arg) old_count = test_cells_written; channel_write_cell(ch, cell); cell = NULL; - test_eq(test_cells_written, old_count + 1); - test_assert(ch->n_bytes_xmitted > 0); - test_assert(ch->n_cells_xmitted > 0); + tt_int_op(test_cells_written, ==, old_count + 1); + tt_assert(ch->n_bytes_xmitted > 0); + tt_assert(ch->n_cells_xmitted > 0); /* Receive path */ channel_set_cell_handlers(ch, chan_test_cell_handler, chan_test_var_cell_handler); - test_eq(channel_get_cell_handler(ch), chan_test_cell_handler); - test_eq(channel_get_var_cell_handler(ch), chan_test_var_cell_handler); + tt_ptr_op(channel_get_cell_handler(ch), ==, chan_test_cell_handler); + tt_ptr_op(channel_get_var_cell_handler(ch), ==, chan_test_var_cell_handler); cell = tor_malloc_zero(sizeof(cell_t)); make_fake_cell(cell); old_count = test_chan_fixed_cells_recved; channel_queue_cell(ch, cell); cell = NULL; - test_eq(test_chan_fixed_cells_recved, old_count + 1); - test_assert(ch->n_bytes_recved > 0); - test_assert(ch->n_cells_recved > 0); + tt_int_op(test_chan_fixed_cells_recved, ==, old_count + 1); + tt_assert(ch->n_bytes_recved > 0); + tt_assert(ch->n_cells_recved > 0); /* Test channel_dump_statistics */ ch->describe_transport = chan_test_describe_transport; @@ -598,13 +598,13 @@ test_channel_dumpstats(void *arg) ch->is_canonical = chan_test_is_canonical; old_count = test_dumpstats_calls; channel_dump_statistics(ch, LOG_DEBUG); - test_eq(test_dumpstats_calls, old_count + 1); + tt_int_op(test_dumpstats_calls, ==, old_count + 1); /* Close the channel */ channel_mark_for_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSED); channel_run_cleanup(); ch = NULL; @@ -629,10 +629,12 @@ test_channel_flush(void *arg) (void)arg; +#ifdef ENABLE_MEMPOOLS init_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); /* Cache the original count */ init_count = test_cells_written; @@ -645,21 +647,21 @@ test_channel_flush(void *arg) make_fake_cell(cell); channel_write_cell(ch, cell); /* It should be queued, so assert that we didn't write it */ - test_eq(test_cells_written, init_count); + tt_int_op(test_cells_written, ==, init_count); /* Queue a var cell */ v_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); make_fake_var_cell(v_cell); channel_write_var_cell(ch, v_cell); /* It should be queued, so assert that we didn't write it */ - test_eq(test_cells_written, init_count); + tt_int_op(test_cells_written, ==, init_count); /* Try a packed cell now */ p_cell = packed_cell_new(); - test_assert(p_cell); + tt_assert(p_cell); channel_write_packed_cell(ch, p_cell); /* It should be queued, so assert that we didn't write it */ - test_eq(test_cells_written, init_count); + tt_int_op(test_cells_written, ==, init_count); /* Now allow writes through again */ test_chan_accept_cells = 1; @@ -668,11 +670,13 @@ test_channel_flush(void *arg) channel_flush_cells(ch); /* All three should have gone through */ - test_eq(test_cells_written, init_count + 3); + tt_int_op(test_cells_written, ==, init_count + 3); done: tor_free(ch); +#ifdef ENABLE_MEMPOOLS free_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ return; } @@ -690,7 +694,9 @@ test_channel_flushmux(void *arg) (void)arg; +#ifdef ENABLE_MEMPOOLS init_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ /* Install mocks we need for this test */ MOCK(channel_flush_from_first_active_circuit, @@ -699,7 +705,7 @@ test_channel_flushmux(void *arg) chan_test_circuitmux_num_cells_mock); ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->cmux = circuitmux_alloc(); old_count = test_cells_written; @@ -712,9 +718,9 @@ test_channel_flushmux(void *arg) result = channel_flush_some_cells(ch, 1); - test_eq(result, 1); - test_eq(test_cells_written, old_count + 1); - test_eq(test_cmux_cells, 0); + tt_int_op(result, ==, 1); + tt_int_op(test_cells_written, ==, old_count + 1); + tt_int_op(test_cmux_cells, ==, 0); /* Now try it without accepting to force them into the queue */ test_chan_accept_cells = 0; @@ -724,19 +730,19 @@ test_channel_flushmux(void *arg) result = channel_flush_some_cells(ch, 1); /* We should not have actually flushed any */ - test_eq(result, 0); - test_eq(test_cells_written, old_count + 1); + tt_int_op(result, ==, 0); + tt_int_op(test_cells_written, ==, old_count + 1); /* But we should have gotten to the fake cellgen loop */ - test_eq(test_cmux_cells, 0); + tt_int_op(test_cmux_cells, ==, 0); /* ...and we should have a queued cell */ q_len_after = chan_cell_queue_len(&(ch->outgoing_queue)); - test_eq(q_len_after, q_len_before + 1); + tt_int_op(q_len_after, ==, q_len_before + 1); /* Now accept cells again and drain the queue */ test_chan_accept_cells = 1; channel_flush_cells(ch); - test_eq(test_cells_written, old_count + 2); - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + tt_int_op(test_cells_written, ==, old_count + 2); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 0); test_target_cmux = NULL; test_cmux_cells = 0; @@ -749,7 +755,9 @@ test_channel_flushmux(void *arg) test_chan_accept_cells = 0; +#ifdef ENABLE_MEMPOOLS free_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ return; } @@ -776,7 +784,7 @@ test_channel_incoming(void *arg) test_overhead_estimate = 1.0f; ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); /* Start it off in OPENING */ ch->state = CHANNEL_STATE_OPENING; /* We'll need a cmux */ @@ -787,16 +795,16 @@ test_channel_incoming(void *arg) chan_test_cell_handler, chan_test_var_cell_handler); /* Test cell handler getters */ - test_eq(channel_get_cell_handler(ch), chan_test_cell_handler); - test_eq(channel_get_var_cell_handler(ch), chan_test_var_cell_handler); + tt_ptr_op(channel_get_cell_handler(ch), ==, chan_test_cell_handler); + tt_ptr_op(channel_get_var_cell_handler(ch), ==, chan_test_var_cell_handler); /* Try to register it */ channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Open it */ channel_change_state(ch, CHANNEL_STATE_OPEN); - test_eq(ch->state, CHANNEL_STATE_OPEN); + tt_int_op(ch->state, ==, CHANNEL_STATE_OPEN); /* Receive a fixed cell */ cell = tor_malloc_zero(sizeof(cell_t)); @@ -804,7 +812,7 @@ test_channel_incoming(void *arg) old_count = test_chan_fixed_cells_recved; channel_queue_cell(ch, cell); cell = NULL; - test_eq(test_chan_fixed_cells_recved, old_count + 1); + tt_int_op(test_chan_fixed_cells_recved, ==, old_count + 1); /* Receive a variable-size cell */ var_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); @@ -812,13 +820,13 @@ test_channel_incoming(void *arg) old_count = test_chan_var_cells_recved; channel_queue_var_cell(ch, var_cell); var_cell = NULL; - test_eq(test_chan_var_cells_recved, old_count + 1); + tt_int_op(test_chan_var_cells_recved, ==, old_count + 1); /* Close it */ channel_mark_for_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSED); channel_run_cleanup(); ch = NULL; @@ -865,7 +873,7 @@ test_channel_lifecycle(void *arg) test_overhead_estimate = 1.0f; ch1 = new_fake_channel(); - test_assert(ch1); + tt_assert(ch1); /* Start it off in OPENING */ ch1->state = CHANNEL_STATE_OPENING; /* We'll need a cmux */ @@ -873,62 +881,67 @@ test_channel_lifecycle(void *arg) /* Try to register it */ channel_register(ch1); - test_assert(ch1->registered); + tt_assert(ch1->registered); /* Try to write a cell through (should queue) */ cell = tor_malloc_zero(sizeof(cell_t)); make_fake_cell(cell); old_count = test_cells_written; channel_write_cell(ch1, cell); - test_eq(old_count, test_cells_written); + tt_int_op(old_count, ==, test_cells_written); /* Move it to OPEN and flush */ channel_change_state(ch1, CHANNEL_STATE_OPEN); /* Queue should drain */ - test_eq(old_count + 1, test_cells_written); + tt_int_op(old_count + 1, ==, test_cells_written); /* Get another one */ ch2 = new_fake_channel(); - test_assert(ch2); + tt_assert(ch2); ch2->state = CHANNEL_STATE_OPENING; ch2->cmux = circuitmux_alloc(); /* Register */ channel_register(ch2); - test_assert(ch2->registered); + tt_assert(ch2->registered); /* Check counters */ - test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count); - test_eq(test_releases_count, init_releases_count); + tt_int_op(test_doesnt_want_writes_count, ==, init_doesnt_want_writes_count); + tt_int_op(test_releases_count, ==, init_releases_count); /* Move ch1 to MAINT */ channel_change_state(ch1, CHANNEL_STATE_MAINT); - test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); - test_eq(test_releases_count, init_releases_count); + tt_int_op(test_doesnt_want_writes_count, ==, + init_doesnt_want_writes_count + 1); + tt_int_op(test_releases_count, ==, init_releases_count); /* Move ch2 to OPEN */ channel_change_state(ch2, CHANNEL_STATE_OPEN); - test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); - test_eq(test_releases_count, init_releases_count); + tt_int_op(test_doesnt_want_writes_count, ==, + init_doesnt_want_writes_count + 1); + tt_int_op(test_releases_count, ==, init_releases_count); /* Move ch1 back to OPEN */ channel_change_state(ch1, CHANNEL_STATE_OPEN); - test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); - test_eq(test_releases_count, init_releases_count); + tt_int_op(test_doesnt_want_writes_count, ==, + init_doesnt_want_writes_count + 1); + tt_int_op(test_releases_count, ==, init_releases_count); /* Mark ch2 for close */ channel_mark_for_close(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSING); - test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); - test_eq(test_releases_count, init_releases_count + 1); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSING); + tt_int_op(test_doesnt_want_writes_count, ==, + init_doesnt_want_writes_count + 1); + tt_int_op(test_releases_count, ==, init_releases_count + 1); /* Shut down channels */ channel_free_all(); ch1 = ch2 = NULL; - test_eq(test_doesnt_want_writes_count, init_doesnt_want_writes_count + 1); + tt_int_op(test_doesnt_want_writes_count, ==, + init_doesnt_want_writes_count + 1); /* channel_free() calls scheduler_release_channel() */ - test_eq(test_releases_count, init_releases_count + 4); + tt_int_op(test_releases_count, ==, init_releases_count + 4); done: tor_free(ch1); @@ -968,7 +981,7 @@ test_channel_lifecycle_2(void *arg) test_overhead_estimate = 1.0f; ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); /* Start it off in OPENING */ ch->state = CHANNEL_STATE_OPENING; /* The full lifecycle test needs a cmux */ @@ -976,60 +989,60 @@ test_channel_lifecycle_2(void *arg) /* Try to register it */ channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Try to close it */ channel_mark_for_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); /* Finish closing it */ chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSED); channel_run_cleanup(); ch = NULL; /* Now try OPENING->OPEN->CLOSING->ERROR */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->state = CHANNEL_STATE_OPENING; ch->cmux = circuitmux_alloc(); channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Finish opening it */ channel_change_state(ch, CHANNEL_STATE_OPEN); /* Error exit from lower layer */ chan_test_error(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_ERROR); + tt_int_op(ch->state, ==, CHANNEL_STATE_ERROR); channel_run_cleanup(); ch = NULL; /* OPENING->OPEN->MAINT->CLOSING->CLOSED close from maintenance state */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->state = CHANNEL_STATE_OPENING; ch->cmux = circuitmux_alloc(); channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Finish opening it */ channel_change_state(ch, CHANNEL_STATE_OPEN); - test_eq(ch->state, CHANNEL_STATE_OPEN); + tt_int_op(ch->state, ==, CHANNEL_STATE_OPEN); /* Go to maintenance state */ channel_change_state(ch, CHANNEL_STATE_MAINT); - test_eq(ch->state, CHANNEL_STATE_MAINT); + tt_int_op(ch->state, ==, CHANNEL_STATE_MAINT); /* Lower layer close */ channel_mark_for_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); /* Finish */ chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSED); channel_run_cleanup(); ch = NULL; @@ -1038,53 +1051,53 @@ test_channel_lifecycle_2(void *arg) * maintenance state */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->state = CHANNEL_STATE_OPENING; ch->cmux = circuitmux_alloc(); channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Finish opening it */ channel_change_state(ch, CHANNEL_STATE_OPEN); - test_eq(ch->state, CHANNEL_STATE_OPEN); + tt_int_op(ch->state, ==, CHANNEL_STATE_OPEN); /* Go to maintenance state */ channel_change_state(ch, CHANNEL_STATE_MAINT); - test_eq(ch->state, CHANNEL_STATE_MAINT); + tt_int_op(ch->state, ==, CHANNEL_STATE_MAINT); /* Lower layer close */ channel_close_from_lower_layer(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); /* Finish */ chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSED); channel_run_cleanup(); ch = NULL; /* OPENING->OPEN->MAINT->CLOSING->ERROR */ ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); ch->state = CHANNEL_STATE_OPENING; ch->cmux = circuitmux_alloc(); channel_register(ch); - test_assert(ch->registered); + tt_assert(ch->registered); /* Finish opening it */ channel_change_state(ch, CHANNEL_STATE_OPEN); - test_eq(ch->state, CHANNEL_STATE_OPEN); + tt_int_op(ch->state, ==, CHANNEL_STATE_OPEN); /* Go to maintenance state */ channel_change_state(ch, CHANNEL_STATE_MAINT); - test_eq(ch->state, CHANNEL_STATE_MAINT); + tt_int_op(ch->state, ==, CHANNEL_STATE_MAINT); /* Lower layer close */ chan_test_error(ch); - test_eq(ch->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch->state, ==, CHANNEL_STATE_CLOSING); /* Finish */ chan_test_finish_close(ch); - test_eq(ch->state, CHANNEL_STATE_ERROR); + tt_int_op(ch->state, ==, CHANNEL_STATE_ERROR); channel_run_cleanup(); ch = NULL; @@ -1115,17 +1128,17 @@ test_channel_multi(void *arg) test_overhead_estimate = 1.0f; ch1 = new_fake_channel(); - test_assert(ch1); + tt_assert(ch1); ch2 = new_fake_channel(); - test_assert(ch2); + tt_assert(ch2); /* Initial queue size update */ channel_update_xmit_queue_size(ch1); - test_eq(ch1->bytes_queued_for_xmit, 0); + tt_int_op(ch1->bytes_queued_for_xmit, ==, 0); channel_update_xmit_queue_size(ch2); - test_eq(ch2->bytes_queued_for_xmit, 0); + tt_int_op(ch2->bytes_queued_for_xmit, ==, 0); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 0); + tt_int_op(global_queue_estimate, ==, 0); /* Queue some cells, check queue estimates */ cell = tor_malloc_zero(sizeof(cell_t)); @@ -1138,10 +1151,10 @@ test_channel_multi(void *arg) channel_update_xmit_queue_size(ch1); channel_update_xmit_queue_size(ch2); - test_eq(ch1->bytes_queued_for_xmit, 0); - test_eq(ch2->bytes_queued_for_xmit, 0); + tt_int_op(ch1->bytes_queued_for_xmit, ==, 0); + tt_int_op(ch2->bytes_queued_for_xmit, ==, 0); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 0); + tt_int_op(global_queue_estimate, ==, 0); /* Stop accepting cells at lower layer */ test_chan_accept_cells = 0; @@ -1152,18 +1165,18 @@ test_channel_multi(void *arg) channel_write_cell(ch1, cell); channel_update_xmit_queue_size(ch1); - test_eq(ch1->bytes_queued_for_xmit, 512); + tt_int_op(ch1->bytes_queued_for_xmit, ==, 512); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 512); + tt_int_op(global_queue_estimate, ==, 512); cell = tor_malloc_zero(sizeof(cell_t)); make_fake_cell(cell); channel_write_cell(ch2, cell); channel_update_xmit_queue_size(ch2); - test_eq(ch2->bytes_queued_for_xmit, 512); + tt_int_op(ch2->bytes_queued_for_xmit, ==, 512); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 1024); + tt_int_op(global_queue_estimate, ==, 1024); /* Allow cells through again */ test_chan_accept_cells = 1; @@ -1174,10 +1187,10 @@ test_channel_multi(void *arg) /* Update and check queue sizes */ channel_update_xmit_queue_size(ch1); channel_update_xmit_queue_size(ch2); - test_eq(ch1->bytes_queued_for_xmit, 512); - test_eq(ch2->bytes_queued_for_xmit, 0); + tt_int_op(ch1->bytes_queued_for_xmit, ==, 512); + tt_int_op(ch2->bytes_queued_for_xmit, ==, 0); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 512); + tt_int_op(global_queue_estimate, ==, 512); /* Flush chan 1 */ channel_flush_cells(ch1); @@ -1185,10 +1198,10 @@ test_channel_multi(void *arg) /* Update and check queue sizes */ channel_update_xmit_queue_size(ch1); channel_update_xmit_queue_size(ch2); - test_eq(ch1->bytes_queued_for_xmit, 0); - test_eq(ch2->bytes_queued_for_xmit, 0); + tt_int_op(ch1->bytes_queued_for_xmit, ==, 0); + tt_int_op(ch2->bytes_queued_for_xmit, ==, 0); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 0); + tt_int_op(global_queue_estimate, ==, 0); /* Now block again */ test_chan_accept_cells = 0; @@ -1205,10 +1218,10 @@ test_channel_multi(void *arg) /* Check the estimates */ channel_update_xmit_queue_size(ch1); channel_update_xmit_queue_size(ch2); - test_eq(ch1->bytes_queued_for_xmit, 512); - test_eq(ch2->bytes_queued_for_xmit, 512); + tt_int_op(ch1->bytes_queued_for_xmit, ==, 512); + tt_int_op(ch2->bytes_queued_for_xmit, ==, 512); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 1024); + tt_int_op(global_queue_estimate, ==, 1024); /* Now close channel 2; it should be subtracted from the global queue */ MOCK(scheduler_release_channel, scheduler_release_channel_mock); @@ -1216,7 +1229,7 @@ test_channel_multi(void *arg) UNMOCK(scheduler_release_channel); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 512); + tt_int_op(global_queue_estimate, ==, 512); /* * Since the fake channels aren't registered, channel_free_all() can't @@ -1227,7 +1240,7 @@ test_channel_multi(void *arg) UNMOCK(scheduler_release_channel); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 0); + tt_int_op(global_queue_estimate, ==, 0); /* Now free everything */ MOCK(scheduler_release_channel, scheduler_release_channel_mock); @@ -1262,13 +1275,15 @@ test_channel_queue_impossible(void *arg) (void)arg; +#ifdef ENABLE_MEMPOOLS init_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ packed_cell = packed_cell_new(); - test_assert(packed_cell); + tt_assert(packed_cell); ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); /* We test queueing here; tell it not to accept cells */ test_chan_accept_cells = 0; @@ -1279,7 +1294,7 @@ test_channel_queue_impossible(void *arg) old_count = test_cells_written; /* Assert that the queue is initially empty */ - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 0); /* Get a fresh cell and write it to the channel*/ cell = tor_malloc_zero(sizeof(cell_t)); @@ -1287,12 +1302,12 @@ test_channel_queue_impossible(void *arg) channel_write_cell(ch, cell); /* Now it should be queued */ - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)),1); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 1); q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); - test_assert(q); + tt_assert(q); if (q) { - test_eq(q->type, CELL_QUEUE_FIXED); - test_eq(q->u.fixed.cell, cell); + tt_int_op(q->type, ==, CELL_QUEUE_FIXED); + tt_ptr_op(q->u.fixed.cell, ==, cell); } /* Do perverse things to it */ tor_free(q->u.fixed.cell); @@ -1304,8 +1319,8 @@ test_channel_queue_impossible(void *arg) */ test_chan_accept_cells = 1; channel_change_state(ch, CHANNEL_STATE_OPEN); - test_assert(test_cells_written == old_count); - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + tt_assert(test_cells_written == old_count); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 0); /* Same thing but for a var_cell */ @@ -1316,12 +1331,12 @@ test_channel_queue_impossible(void *arg) channel_write_var_cell(ch, var_cell); /* Check that it's queued */ - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 1); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 1); q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); - test_assert(q); + tt_assert(q); if (q) { - test_eq(q->type, CELL_QUEUE_VAR); - test_eq(q->u.var.var_cell, var_cell); + tt_int_op(q->type, ==, CELL_QUEUE_VAR); + tt_ptr_op(q->u.var.var_cell, ==, var_cell); } /* Remove the cell from the queue entry */ @@ -1331,24 +1346,24 @@ test_channel_queue_impossible(void *arg) /* Let it drain and check that the bad entry is discarded */ test_chan_accept_cells = 1; channel_change_state(ch, CHANNEL_STATE_OPEN); - test_assert(test_cells_written == old_count); - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + tt_assert(test_cells_written == old_count); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 0); /* Same thing with a packed_cell */ test_chan_accept_cells = 0; ch->state = CHANNEL_STATE_MAINT; packed_cell = packed_cell_new(); - test_assert(packed_cell); + tt_assert(packed_cell); channel_write_packed_cell(ch, packed_cell); /* Check that it's queued */ - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 1); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 1); q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); - test_assert(q); + tt_assert(q); if (q) { - test_eq(q->type, CELL_QUEUE_PACKED); - test_eq(q->u.packed.packed_cell, packed_cell); + tt_int_op(q->type, ==, CELL_QUEUE_PACKED); + tt_ptr_op(q->u.packed.packed_cell, ==, packed_cell); } /* Remove the cell from the queue entry */ @@ -1358,8 +1373,8 @@ test_channel_queue_impossible(void *arg) /* Let it drain and check that the bad entry is discarded */ test_chan_accept_cells = 1; channel_change_state(ch, CHANNEL_STATE_OPEN); - test_assert(test_cells_written == old_count); - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + tt_assert(test_cells_written == old_count); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 0); /* Unknown cell type case */ test_chan_accept_cells = 0; @@ -1369,12 +1384,12 @@ test_channel_queue_impossible(void *arg) channel_write_cell(ch, cell); /* Check that it's queued */ - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)),1); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 1); q = TOR_SIMPLEQ_FIRST(&(ch->outgoing_queue)); - test_assert(q); + tt_assert(q); if (q) { - test_eq(q->type, CELL_QUEUE_FIXED); - test_eq(q->u.fixed.cell, cell); + tt_int_op(q->type, ==, CELL_QUEUE_FIXED); + tt_ptr_op(q->u.fixed.cell, ==, cell); } /* Clobber it, including the queue entry type */ tor_free(q->u.fixed.cell); @@ -1384,12 +1399,14 @@ test_channel_queue_impossible(void *arg) /* Let it drain and check that the bad entry is discarded */ test_chan_accept_cells = 1; channel_change_state(ch, CHANNEL_STATE_OPEN); - test_assert(test_cells_written == old_count); - test_eq(chan_cell_queue_len(&(ch->outgoing_queue)), 0); + tt_assert(test_cells_written == old_count); + tt_int_op(chan_cell_queue_len(&(ch->outgoing_queue)), ==, 0); done: tor_free(ch); +#ifdef ENABLE_MEMPOOLS free_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ /* * Doing that meant that we couldn't correctly adjust the queue size @@ -1412,18 +1429,18 @@ test_channel_queue_size(void *arg) (void)arg; ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); /* Initial queue size update */ channel_update_xmit_queue_size(ch); - test_eq(ch->bytes_queued_for_xmit, 0); + tt_int_op(ch->bytes_queued_for_xmit, ==, 0); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 0); + tt_int_op(global_queue_estimate, ==, 0); /* Test the call-through to our fake lower layer */ n = channel_num_cells_writeable(ch); /* chan_test_num_cells_writeable() always returns 32 */ - test_eq(n, 32); + tt_int_op(n, ==, 32); /* * Now we queue some cells and check that channel_num_cells_writeable() @@ -1442,32 +1459,32 @@ test_channel_queue_size(void *arg) old_count = test_cells_written; channel_write_cell(ch, cell); /* Assert that it got queued, not written through, correctly */ - test_eq(test_cells_written, old_count); + tt_int_op(test_cells_written, ==, old_count); /* Now check chan_test_num_cells_writeable() again */ n = channel_num_cells_writeable(ch); - test_eq(n, 0); /* Should return 0 since we're in CHANNEL_STATE_MAINT */ + tt_int_op(n, ==, 0); /* Should return 0 since we're in CHANNEL_STATE_MAINT */ /* Update queue size estimates */ channel_update_xmit_queue_size(ch); /* One cell, times an overhead factor of 1.0 */ - test_eq(ch->bytes_queued_for_xmit, 512); + tt_int_op(ch->bytes_queued_for_xmit, ==, 512); /* Try a different overhead factor */ test_overhead_estimate = 0.5f; /* This one should be ignored since it's below 1.0 */ channel_update_xmit_queue_size(ch); - test_eq(ch->bytes_queued_for_xmit, 512); + tt_int_op(ch->bytes_queued_for_xmit, ==, 512); /* Now try a larger one */ test_overhead_estimate = 2.0f; channel_update_xmit_queue_size(ch); - test_eq(ch->bytes_queued_for_xmit, 1024); + tt_int_op(ch->bytes_queued_for_xmit, ==, 1024); /* Go back to 1.0 */ test_overhead_estimate = 1.0f; channel_update_xmit_queue_size(ch); - test_eq(ch->bytes_queued_for_xmit, 512); + tt_int_op(ch->bytes_queued_for_xmit, ==, 512); /* Check the global estimate too */ global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 512); + tt_int_op(global_queue_estimate, ==, 512); /* Go to open */ old_count = test_cells_written; @@ -1477,37 +1494,37 @@ test_channel_queue_size(void *arg) * It should try to write, but we aren't accepting cells right now, so * it'll requeue */ - test_eq(test_cells_written, old_count); + tt_int_op(test_cells_written, ==, old_count); /* Check the queue size again */ channel_update_xmit_queue_size(ch); - test_eq(ch->bytes_queued_for_xmit, 512); + tt_int_op(ch->bytes_queued_for_xmit, ==, 512); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 512); + tt_int_op(global_queue_estimate, ==, 512); /* * Now the cell is in the queue, and we're open, so we should get 31 * writeable cells. */ n = channel_num_cells_writeable(ch); - test_eq(n, 31); + tt_int_op(n, ==, 31); /* Accept cells again */ test_chan_accept_cells = 1; /* ...and re-process the queue */ old_count = test_cells_written; channel_flush_cells(ch); - test_eq(test_cells_written, old_count + 1); + tt_int_op(test_cells_written, ==, old_count + 1); /* Should have 32 writeable now */ n = channel_num_cells_writeable(ch); - test_eq(n, 32); + tt_int_op(n, ==, 32); /* Should have queue size estimate of zero */ channel_update_xmit_queue_size(ch); - test_eq(ch->bytes_queued_for_xmit, 0); + tt_int_op(ch->bytes_queued_for_xmit, ==, 0); global_queue_estimate = channel_get_global_queue_estimate(); - test_eq(global_queue_estimate, 0); + tt_int_op(global_queue_estimate, ==, 0); /* Okay, now we're done with this one */ MOCK(scheduler_release_channel, scheduler_release_channel_mock); @@ -1532,13 +1549,15 @@ test_channel_write(void *arg) (void)arg; +#ifdef ENABLE_MEMPOOLS init_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ packed_cell = packed_cell_new(); - test_assert(packed_cell); + tt_assert(packed_cell); ch = new_fake_channel(); - test_assert(ch); + tt_assert(ch); make_fake_cell(cell); make_fake_var_cell(var_cell); @@ -1547,13 +1566,13 @@ test_channel_write(void *arg) old_count = test_cells_written; channel_write_cell(ch, cell); - test_assert(test_cells_written == old_count + 1); + tt_assert(test_cells_written == old_count + 1); channel_write_var_cell(ch, var_cell); - test_assert(test_cells_written == old_count + 2); + tt_assert(test_cells_written == old_count + 2); channel_write_packed_cell(ch, packed_cell); - test_assert(test_cells_written == old_count + 3); + tt_assert(test_cells_written == old_count + 3); /* Now we test queueing; tell it not to accept cells */ test_chan_accept_cells = 0; @@ -1566,7 +1585,7 @@ test_channel_write(void *arg) old_count = test_cells_written; channel_write_cell(ch, cell); - test_assert(test_cells_written == old_count); + tt_assert(test_cells_written == old_count); /* * Now change back to open with channel_change_state() and assert that it @@ -1574,7 +1593,7 @@ test_channel_write(void *arg) */ test_chan_accept_cells = 1; channel_change_state(ch, CHANNEL_STATE_OPEN); - test_assert(test_cells_written == old_count + 1); + tt_assert(test_cells_written == old_count + 1); /* * Check the note destroy case @@ -1589,13 +1608,13 @@ test_channel_write(void *arg) old_count = test_destroy_not_pending_calls; channel_write_cell(ch, cell); - test_assert(test_destroy_not_pending_calls == old_count + 1); + tt_assert(test_destroy_not_pending_calls == old_count + 1); /* Now send a non-destroy and check we don't call it */ cell = tor_malloc_zero(sizeof(cell_t)); make_fake_cell(cell); channel_write_cell(ch, cell); - test_assert(test_destroy_not_pending_calls == old_count + 1); + tt_assert(test_destroy_not_pending_calls == old_count + 1); UNMOCK(channel_note_destroy_not_pending); @@ -1613,18 +1632,20 @@ test_channel_write(void *arg) cell = tor_malloc_zero(sizeof(cell_t)); make_fake_cell(cell); channel_write_cell(ch, cell); - test_assert(test_cells_written == old_count); + tt_assert(test_cells_written == old_count); var_cell = tor_malloc_zero(sizeof(var_cell_t) + CELL_PAYLOAD_SIZE); make_fake_var_cell(var_cell); channel_write_var_cell(ch, var_cell); - test_assert(test_cells_written == old_count); + tt_assert(test_cells_written == old_count); packed_cell = packed_cell_new(); channel_write_packed_cell(ch, packed_cell); - test_assert(test_cells_written == old_count); + tt_assert(test_cells_written == old_count); +#ifdef ENABLE_MEMPOOLS free_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ done: tor_free(ch);

1 0

[tor/master] Update test_relay.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 4d20c427b4874a3cb97e4567e4ae54830c5a79be Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 07:22:26 2014 -0700 Update test_relay.c for recent test suite changes and --enable-mempools support --- src/test/test_relay.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/test/test_relay.c b/src/test/test_relay.c index 6b9cb33..6907597 100644 --- a/src/test/test_relay.c +++ b/src/test/test_relay.c @@ -61,14 +61,16 @@ test_relay_append_cell_to_circuit_queue(void *arg) (void)arg; /* We'll need the cell pool for append_cell_to_circuit_queue() to work */ +#ifdef ENABLE_MEMPOOLS init_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ /* Make fake channels to be nchan and pchan for the circuit */ nchan = new_fake_channel(); - test_assert(nchan); + tt_assert(nchan); pchan = new_fake_channel(); - test_assert(pchan); + tt_assert(pchan); /* We'll need chans with working cmuxes */ nchan->cmux = circuitmux_alloc(); @@ -76,7 +78,7 @@ test_relay_append_cell_to_circuit_queue(void *arg) /* Make a fake orcirc */ orcirc = new_fake_orcirc(nchan, pchan); - test_assert(orcirc); + tt_assert(orcirc); /* Make a cell */ cell = tor_malloc_zero(sizeof(cell_t)); @@ -90,14 +92,14 @@ test_relay_append_cell_to_circuit_queue(void *arg) append_cell_to_circuit_queue(TO_CIRCUIT(orcirc), nchan, cell, CELL_DIRECTION_OUT, 0); new_count = get_mock_scheduler_has_waiting_cells_count(); - test_eq(new_count, old_count + 1); + tt_int_op(new_count, ==, old_count + 1); /* Now try the reverse direction */ old_count = get_mock_scheduler_has_waiting_cells_count(); append_cell_to_circuit_queue(TO_CIRCUIT(orcirc), pchan, cell, CELL_DIRECTION_IN, 0); new_count = get_mock_scheduler_has_waiting_cells_count(); - test_eq(new_count, old_count + 1); + tt_int_op(new_count, ==, old_count + 1); UNMOCK(scheduler_channel_has_waiting_cells); @@ -117,7 +119,9 @@ test_relay_append_cell_to_circuit_queue(void *arg) tor_free(nchan); if (pchan && pchan->cmux) circuitmux_free(pchan->cmux); tor_free(pchan); +#ifdef ENABLE_MEMPOOLS free_cell_pool(); +#endif /* ENABLE_MEMPOOLS */ return; }

1 0

[tor/master] Add scheduler/loop unit test
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit 41cf9f6260d70de8b07740c89fd5273b4f073c95 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Feb 4 13:59:53 2014 -0800 Add scheduler/loop unit test --- src/test/test_scheduler.c | 303 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 303 insertions(+) diff --git a/src/test/test_scheduler.c b/src/test/test_scheduler.c index 650d4f1..79fc453 100644 --- a/src/test/test_scheduler.c +++ b/src/test/test_scheduler.c @@ -44,11 +44,17 @@ static const circuitmux_policy_t *mock_cgp_val_2 = NULL; static int scheduler_compare_channels_mock_ctr = 0; static int scheduler_run_mock_ctr = 0; +static void channel_flush_some_cells_mock_free_all(void); +static void channel_flush_some_cells_mock_set(channel_t *chan, + ssize_t num_cells); + /* Setup for mock event stuff */ static void mock_event_free_all(void); static void mock_event_init(void); /* Mocks used by scheduler tests */ +static ssize_t channel_flush_some_cells_mock(channel_t *chan, + ssize_t num_cells); static int circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, circuitmux_t *cmux_2); static const circuitmux_policy_t * circuitmux_get_policy_mock( @@ -62,6 +68,7 @@ static struct event_base * tor_libevent_get_base_mock(void); static void test_scheduler_channel_states(void *arg); static void test_scheduler_compare_channels(void *arg); static void test_scheduler_initfree(void *arg); +static void test_scheduler_loop(void *arg); static void test_scheduler_queue_heuristic(void *arg); /* Mock event init/free */ @@ -123,6 +130,120 @@ mock_event_init(void) /* Mocks */ +typedef struct { + const channel_t *chan; + ssize_t cells; +} flush_mock_channel_t; + +static smartlist_t *chans_for_flush_mock = NULL; + +static void +channel_flush_some_cells_mock_free_all(void) +{ + if (chans_for_flush_mock) { + SMARTLIST_FOREACH_BEGIN(chans_for_flush_mock, + flush_mock_channel_t *, + flush_mock_ch) { + SMARTLIST_DEL_CURRENT(chans_for_flush_mock, flush_mock_ch); + tor_free(flush_mock_ch); + } SMARTLIST_FOREACH_END(flush_mock_ch); + + smartlist_free(chans_for_flush_mock); + chans_for_flush_mock = NULL; + } +} + +static void +channel_flush_some_cells_mock_set(channel_t *chan, ssize_t num_cells) +{ + flush_mock_channel_t *flush_mock_ch = NULL; + + if (!chan) return; + if (num_cells <= 0) return; + + if (!chans_for_flush_mock) { + chans_for_flush_mock = smartlist_new(); + } + + SMARTLIST_FOREACH_BEGIN(chans_for_flush_mock, + flush_mock_channel_t *, + flush_mock_ch) { + if (flush_mock_ch != NULL && flush_mock_ch->chan != NULL) { + if (flush_mock_ch->chan == chan) { + /* Found it */ + flush_mock_ch->cells = num_cells; + break; + } + } else { + /* That shouldn't be there... */ + SMARTLIST_DEL_CURRENT(chans_for_flush_mock, flush_mock_ch); + tor_free(flush_mock_ch); + } + } SMARTLIST_FOREACH_END(flush_mock_ch); + + if (!flush_mock_ch) { + /* The loop didn't find it */ + flush_mock_ch = tor_malloc_zero(sizeof(*flush_mock_ch)); + flush_mock_ch->chan = chan; + flush_mock_ch->cells = num_cells; + smartlist_add(chans_for_flush_mock, flush_mock_ch); + } +} + +static ssize_t +channel_flush_some_cells_mock(channel_t *chan, ssize_t num_cells) +{ + ssize_t flushed = 0, max; + char unlimited = 0; + flush_mock_channel_t *found = NULL; + + test_assert(chan != NULL); + if (chan) { + if (num_cells < 0) { + num_cells = 0; + unlimited = 1; + } + + /* Check if we have it */ + if (chans_for_flush_mock != NULL) { + SMARTLIST_FOREACH_BEGIN(chans_for_flush_mock, + flush_mock_channel_t *, + flush_mock_ch) { + if (flush_mock_ch != NULL && flush_mock_ch->chan != NULL) { + if (flush_mock_ch->chan == chan) { + /* Found it */ + found = flush_mock_ch; + break; + } + } else { + /* That shouldn't be there... */ + SMARTLIST_DEL_CURRENT(chans_for_flush_mock, flush_mock_ch); + tor_free(flush_mock_ch); + } + } SMARTLIST_FOREACH_END(flush_mock_ch); + + if (found) { + /* We found one */ + if (found->cells < 0) found->cells = 0; + + if (unlimited) max = found->cells; + else max = MIN(found->cells, num_cells); + + flushed += max; + found->cells -= max; + + if (found->cells <= 0) { + smartlist_remove(chans_for_flush_mock, found); + tor_free(found); + } + } + } + } + + done: + return flushed; +} + static int circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, circuitmux_t *cmux_2) @@ -415,6 +536,187 @@ test_scheduler_initfree(void *arg) } static void +test_scheduler_loop(void *arg) +{ + channel_t *ch1 = NULL, *ch2 = NULL; + + (void)arg; + + /* Set up libevent and scheduler */ + + mock_event_init(); + MOCK(tor_libevent_get_base, tor_libevent_get_base_mock); + scheduler_init(); + /* + * Install the compare channels mock so we can test + * scheduler_touch_channel(). + */ + MOCK(scheduler_compare_channels, scheduler_compare_channels_mock); + /* + * Disable scheduler_run so we can just check the state transitions + * without having to make everything it might call work too. + */ + MOCK(scheduler_run, scheduler_run_noop_mock); + + test_eq(smartlist_len(channels_pending), 0); + + /* Set up a fake channel */ + ch1 = new_fake_channel(); + test_assert(ch1); + + /* Start it off in OPENING */ + ch1->state = CHANNEL_STATE_OPENING; + /* We'll need a cmux */ + ch1->cmux = circuitmux_alloc(); + /* Try to register it */ + channel_register(ch1); + test_assert(ch1->registered); + /* Finish opening it */ + channel_change_state(ch1, CHANNEL_STATE_OPEN); + + /* It should start off in SCHED_CHAN_IDLE */ + test_eq(ch1->scheduler_state, SCHED_CHAN_IDLE); + + /* Now get another one */ + ch2 = new_fake_channel(); + test_assert(ch2); + ch2->state = CHANNEL_STATE_OPENING; + ch2->cmux = circuitmux_alloc(); + channel_register(ch2); + test_assert(ch2->registered); + /* + * Don't open ch2; then channel_num_cells_writeable() will return + * zero and we'll get coverage of that exception case in scheduler_run() + */ + + test_eq(ch1->state, CHANNEL_STATE_OPEN); + test_eq(ch2->state, CHANNEL_STATE_OPENING); + + /* Send it to SCHED_CHAN_WAITING_TO_WRITE */ + scheduler_channel_has_waiting_cells(ch1); + test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); + + /* This should send it to SCHED_CHAN_PENDING */ + scheduler_channel_wants_writes(ch1); + test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 1); + + /* Now send ch2 to SCHED_CHAN_WAITING_FOR_CELLS */ + scheduler_channel_wants_writes(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + + /* Drop ch2 back to idle */ + scheduler_channel_doesnt_want_writes(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_IDLE); + + /* ...and back to SCHED_CHAN_WAITING_FOR_CELLS */ + scheduler_channel_wants_writes(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + + /* ...and this should kick ch2 into SCHED_CHAN_PENDING */ + scheduler_channel_has_waiting_cells(ch2); + test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 2); + + /* + * Now we've got two pending channels and need to fire off + * scheduler_run(); first, unmock it. + */ + + UNMOCK(scheduler_run); + + scheduler_run(); + + /* Now re-mock it */ + MOCK(scheduler_run, scheduler_run_noop_mock); + + /* + * Assert that they're still in the states we left and aren't still + * pending + */ + test_eq(ch1->state, CHANNEL_STATE_OPEN); + test_eq(ch2->state, CHANNEL_STATE_OPENING); + test_assert(ch1->scheduler_state != SCHED_CHAN_PENDING); + test_assert(ch2->scheduler_state != SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 0); + + /* Now, finish opening ch2, and get both back to pending */ + channel_change_state(ch2, CHANNEL_STATE_OPEN); + scheduler_channel_wants_writes(ch1); + scheduler_channel_wants_writes(ch2); + scheduler_channel_has_waiting_cells(ch1); + scheduler_channel_has_waiting_cells(ch2); + test_eq(ch1->state, CHANNEL_STATE_OPEN); + test_eq(ch2->state, CHANNEL_STATE_OPEN); + test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); + test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); + test_eq(smartlist_len(channels_pending), 2); + + /* Now, set up the channel_flush_some_cells() mock */ + MOCK(channel_flush_some_cells, channel_flush_some_cells_mock); + /* + * 16 cells on ch1 means it'll completely drain into the 32 cells + * fakechan's num_cells_writeable() returns. + */ + channel_flush_some_cells_mock_set(ch1, 16); + /* + * This one should get sent back to pending, since num_cells_writeable() + * will still return non-zero. + */ + channel_flush_some_cells_mock_set(ch2, 48); + + /* + * And re-run the scheduler_run() loop with non-zero returns from + * channel_flush_some_cells() this time. + */ + UNMOCK(scheduler_run); + + scheduler_run(); + + /* Now re-mock it */ + MOCK(scheduler_run, scheduler_run_noop_mock); + + /* + * ch1 should have gone to SCHED_CHAN_WAITING_FOR_CELLS, with 16 flushed + * and 32 writeable. + */ + test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + /* + * ...ch2 should also have gone to SCHED_CHAN_WAITING_FOR_CELLS, with + * channel_more_to_flush() returning false and channel_num_cells_writeable() + * > 0/ + */ + test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + + /* Close */ + channel_mark_for_close(ch1); + test_eq(ch1->state, CHANNEL_STATE_CLOSING); + channel_mark_for_close(ch2); + test_eq(ch2->state, CHANNEL_STATE_CLOSING); + channel_closed(ch1); + test_eq(ch1->state, CHANNEL_STATE_CLOSED); + ch1 = NULL; + channel_closed(ch2); + test_eq(ch2->state, CHANNEL_STATE_CLOSED); + ch2 = NULL; + + /* Shut things down */ + channel_flush_some_cells_mock_free_all(); + channel_free_all(); + scheduler_free_all(); + mock_event_free_all(); + + done: + tor_free(ch1); + tor_free(ch2); + + UNMOCK(channel_flush_some_cells); + UNMOCK(scheduler_compare_channels); + UNMOCK(scheduler_run); + UNMOCK(tor_libevent_get_base); +} + +static void test_scheduler_queue_heuristic(void *arg) { time_t now = approx_time(); @@ -453,6 +755,7 @@ struct testcase_t scheduler_tests[] = { { "compare_channels", test_scheduler_compare_channels, TT_FORK, NULL, NULL }, { "initfree", test_scheduler_initfree, TT_FORK, NULL, NULL }, + { "loop", test_scheduler_loop, TT_FORK, NULL, NULL }, { "queue_heuristic", test_scheduler_queue_heuristic, TT_FORK, NULL, NULL }, END_OF_TESTCASES

1 0

[tor/master] Fix some issues with the scheduler configuration options
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit b1e1b439b892624b7dbe2f631a9ddb41b16ecdd6 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Nov 27 22:51:13 2014 -0500 Fix some issues with the scheduler configuration options 1) Set them to the values that (according to Rob) avoided performance regressions. This means that the scheduler won't get much exercise until we implement KIST or something like it. 2) Rename the options to end with a __, since I think they might be going away, and nobody should mess with them. 3) Use the correct types for the option variables. MEMUNIT needs to be a uint64_t; UINT needs to be (I know, I know!) an int. 4) Validate the values in options_validate(); do the switch in options_act(). This way, setting the option to an invalid value on a running Tor will get backed out. --- src/or/config.c | 38 ++++++++++++++++++-------------------- src/or/or.h | 6 +++--- 2 files changed, 21 insertions(+), 23 deletions(-) diff --git a/src/or/config.c b/src/or/config.c index ced4288..28f1df0 100644 --- a/src/or/config.c +++ b/src/or/config.c @@ -369,9 +369,9 @@ static config_var_t option_vars_[] = { V(ServerDNSSearchDomains, BOOL, "0"), V(ServerDNSTestAddresses, CSV, "www.google.com,www.mit.edu,www.yahoo.com,www.slashdot.org"), - V(SchedulerLowWaterMark, MEMUNIT, "16 kB"), - V(SchedulerHighWaterMark, MEMUNIT, "32 kB"), - V(SchedulerMaxFlushCells, UINT, "16"), + V(SchedulerLowWaterMark__, MEMUNIT, "100 MB"), + V(SchedulerHighWaterMark__, MEMUNIT, "101 MB"), + V(SchedulerMaxFlushCells__, UINT, "1000"), V(ShutdownWaitLength, INTERVAL, "30 seconds"), V(SocksListenAddress, LINELIST, NULL), V(SocksPolicy, LINELIST, NULL), @@ -1539,23 +1539,10 @@ options_act(const or_options_t *old_options) } /* Set up scheduler thresholds */ - if (options->SchedulerLowWaterMark > 0 && - options->SchedulerHighWaterMark > options->SchedulerLowWaterMark) { - scheduler_set_watermarks(options->SchedulerLowWaterMark, - options->SchedulerHighWaterMark, - (options->SchedulerMaxFlushCells > 0) ? - options->SchedulerMaxFlushCells : 16); - } else { - if (options->SchedulerLowWaterMark == 0) { - log_warn(LD_GENERAL, "Bad SchedulerLowWaterMark option"); - } - - if (options->SchedulerHighWaterMark <= options->SchedulerLowWaterMark) { - log_warn(LD_GENERAL, "Bad SchedulerHighWaterMark option"); - } - - return -1; - } + scheduler_set_watermarks((uint32_t)options->SchedulerLowWaterMark__, + (uint32_t)options->SchedulerHighWaterMark__, + (options->SchedulerMaxFlushCells__ > 0) ? + options->SchedulerMaxFlushCells__ : 1000); /* Set up accounting */ if (accounting_parse_options(options, 0)<0) { @@ -2654,6 +2641,17 @@ options_validate(or_options_t *old_options, or_options_t *options, routerset_union(options->ExcludeExitNodesUnion_,options->ExcludeNodes); } + if (options->SchedulerLowWaterMark__ == 0 || + options->SchedulerLowWaterMark__ > UINT32_MAX) { + log_warn(LD_GENERAL, "Bad SchedulerLowWaterMark__ option"); + return -1; + } else if (options->SchedulerHighWaterMark__ <= + options->SchedulerLowWaterMark__ || + options->SchedulerHighWaterMark__ > UINT32_MAX) { + log_warn(LD_GENERAL, "Bad SchedulerHighWaterMark option"); + return -1; + } + if (options->NodeFamilies) { options->NodeFamilySets = smartlist_new(); for (cl = options->NodeFamilies; cl; cl = cl->next) { diff --git a/src/or/or.h b/src/or/or.h index ccb29ee..0de3745 100644 --- a/src/or/or.h +++ b/src/or/or.h @@ -4251,15 +4251,15 @@ typedef struct { /** Low-water mark for global scheduler - start sending when estimated * queued size falls below this threshold. */ - uint32_t SchedulerLowWaterMark; + uint64_t SchedulerLowWaterMark__; /** High-water mark for global scheduler - stop sending when estimated * queued size exceeds this threshold. */ - uint32_t SchedulerHighWaterMark; + uint64_t SchedulerHighWaterMark__; /** Flush size for global scheduler - flush this many cells at a time * when sending. */ - unsigned int SchedulerMaxFlushCells; + int SchedulerMaxFlushCells__; } or_options_t; /** Persistent state for an onion router, as saved to disk. */

1 0

[tor/master] Update test_channeltls.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit faea058baabec9eeb180a0e1812ca7857f3894e0 Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 07:18:57 2014 -0700 Update test_channeltls.c for recent test suite changes and --enable-mempools support --- src/test/test_channeltls.c | 44 ++++++++++++++++++++++---------------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/src/test/test_channeltls.c b/src/test/test_channeltls.c index 4dcf4c5..45e24df 100644 --- a/src/test/test_channeltls.c +++ b/src/test/test_channeltls.c @@ -69,7 +69,7 @@ test_channeltls_create(void *arg) /* Try connecting */ ch = channel_tls_connect(&test_addr, 567, test_digest); - test_assert(ch != NULL); + tt_assert(ch != NULL); done: if (ch) { @@ -118,7 +118,7 @@ test_channeltls_num_bytes_queued(void *arg) /* Try connecting */ ch = channel_tls_connect(&test_addr, 567, test_digest); - test_assert(ch != NULL); + tt_assert(ch != NULL); /* * Next, we have to test ch->num_bytes_queued, which is @@ -128,9 +128,9 @@ test_channeltls_num_bytes_queued(void *arg) * if bufferevents ever work, this will break with them enabled. */ - test_assert(ch->num_bytes_queued != NULL); + tt_assert(ch->num_bytes_queued != NULL); tlschan = BASE_CHAN_TO_TLS(ch); - test_assert(tlschan != NULL); + tt_assert(tlschan != NULL); if (TO_CONN(tlschan->conn)->outbuf == NULL) { /* We need an outbuf to make sure buf_datalen() gets called */ fake_outbuf = 1; @@ -140,7 +140,7 @@ test_channeltls_num_bytes_queued(void *arg) tlschan_buf_datalen_mock_size = 1024; MOCK(buf_datalen, tlschan_buf_datalen_mock); len = ch->num_bytes_queued(ch); - test_eq(len, tlschan_buf_datalen_mock_size); + tt_int_op(len, ==, tlschan_buf_datalen_mock_size); /* * We also cover num_cells_writeable here; since wide_circ_ids = 0 on * the fake tlschans, cell_network_size returns 512, and so with @@ -149,7 +149,7 @@ test_channeltls_num_bytes_queued(void *arg) * - 2 cells. */ n = ch->num_cells_writeable(ch); - test_eq(n, CEIL_DIV(OR_CONN_HIGHWATER, 512) - 2); + tt_int_op(n, ==, CEIL_DIV(OR_CONN_HIGHWATER, 512) - 2); UNMOCK(buf_datalen); tlschan_buf_datalen_mock_target = NULL; tlschan_buf_datalen_mock_size = 0; @@ -204,33 +204,33 @@ test_channeltls_overhead_estimate(void *arg) /* Try connecting */ ch = channel_tls_connect(&test_addr, 567, test_digest); - test_assert(ch != NULL); + tt_assert(ch != NULL); /* First case: silly low ratios should get clamped to 1.0f */ tlschan = BASE_CHAN_TO_TLS(ch); - test_assert(tlschan != NULL); + tt_assert(tlschan != NULL); tlschan->conn->bytes_xmitted = 128; tlschan->conn->bytes_xmitted_by_tls = 64; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 1.0f) < 1E-12); + tt_assert(fabsf(r - 1.0f) < 1E-12); tlschan->conn->bytes_xmitted_by_tls = 127; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 1.0f) < 1E-12); + tt_assert(fabsf(r - 1.0f) < 1E-12); /* Now middle of the range */ tlschan->conn->bytes_xmitted_by_tls = 192; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 1.5f) < 1E-12); + tt_assert(fabsf(r - 1.5f) < 1E-12); /* Now above the 2.0f clamp */ tlschan->conn->bytes_xmitted_by_tls = 257; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 2.0f) < 1E-12); + tt_assert(fabsf(r - 2.0f) < 1E-12); tlschan->conn->bytes_xmitted_by_tls = 512; r = ch->get_overhead_estimate(ch); - test_assert(fabsf(r - 2.0f) < 1E-12); + tt_assert(fabsf(r - 2.0f) < 1E-12); done: if (ch) { @@ -256,7 +256,7 @@ tlschan_buf_datalen_mock(const buf_t *buf) { if (buf != NULL && buf == tlschan_buf_datalen_mock_target) { return tlschan_buf_datalen_mock_size; - }else { + } else { return buf_datalen__real(buf); } } @@ -269,10 +269,10 @@ tlschan_connection_or_connect_mock(const tor_addr_t *addr, { or_connection_t *result = NULL; - test_assert(addr != NULL); - test_assert(port != 0); - test_assert(digest != NULL); - test_assert(tlschan != NULL); + tt_assert(addr != NULL); + tt_assert(port != 0); + tt_assert(digest != NULL); + tt_assert(tlschan != NULL); /* Make a fake orconn */ result = tor_malloc_zero(sizeof(*result)); @@ -297,11 +297,11 @@ tlschan_fake_close_method(channel_t *chan) { channel_tls_t *tlschan = NULL; - test_assert(chan != NULL); - test_eq(chan->magic, TLS_CHAN_MAGIC); + tt_assert(chan != NULL); + tt_int_op(chan->magic, ==, TLS_CHAN_MAGIC); tlschan = BASE_CHAN_TO_TLS(chan); - test_assert(tlschan != NULL); + tt_assert(tlschan != NULL); /* Just free the fake orconn */ tor_free(tlschan->conn); @@ -315,7 +315,7 @@ tlschan_fake_close_method(channel_t *chan) static int tlschan_is_local_addr_mock(const tor_addr_t *addr) { - test_assert(addr != NULL); + tt_assert(addr != NULL); done: return tlschan_local;

1 0

[tor/master] Update test_relay.c for recent test suite changes and --enable-mempools support
by nickm＠torproject.org 28 Nov '14

28 Nov '14

commit a28cfa128f55c64cfd9562dff7e3b5515d1615ad Author: Andrea Shepard <andrea(a)torproject.org> Date: Tue Sep 23 21:03:09 2014 -0700 Update test_relay.c for recent test suite changes and --enable-mempools support --- src/test/test_scheduler.c | 162 ++++++++++++++++++++++----------------------- 1 file changed, 81 insertions(+), 81 deletions(-) diff --git a/src/test/test_scheduler.c b/src/test/test_scheduler.c index 79fc453..da5c4e8 100644 --- a/src/test/test_scheduler.c +++ b/src/test/test_scheduler.c @@ -80,14 +80,14 @@ static void test_scheduler_queue_heuristic(void *arg); static void mock_event_free_all(void) { - test_assert(mock_event_base != NULL); + tt_assert(mock_event_base != NULL); if (mock_event_base) { event_base_free(mock_event_base); mock_event_base = NULL; } - test_eq(mock_event_base, NULL); + tt_ptr_op(mock_event_base, ==, NULL); done: return; @@ -100,7 +100,7 @@ mock_event_init(void) struct event_config *cfg = NULL; #endif - test_eq(mock_event_base, NULL); + tt_ptr_op(mock_event_base, ==, NULL); /* * Really cut down from tor_libevent_initialize of @@ -122,7 +122,7 @@ mock_event_init(void) #endif } - test_assert(mock_event_base != NULL); + tt_assert(mock_event_base != NULL); done: return; @@ -197,7 +197,7 @@ channel_flush_some_cells_mock(channel_t *chan, ssize_t num_cells) char unlimited = 0; flush_mock_channel_t *found = NULL; - test_assert(chan != NULL); + tt_assert(chan != NULL); if (chan) { if (num_cells < 0) { num_cells = 0; @@ -250,8 +250,8 @@ circuitmux_compare_muxes_mock(circuitmux_t *cmux_1, { int result = 0; - test_assert(cmux_1 != NULL); - test_assert(cmux_2 != NULL); + tt_assert(cmux_1 != NULL); + tt_assert(cmux_2 != NULL); if (cmux_1 != cmux_2) { if (cmux_1 == mock_ccm_tgt_1 && cmux_2 == mock_ccm_tgt_2) result = -1; @@ -277,7 +277,7 @@ circuitmux_get_policy_mock(circuitmux_t *cmux) { const circuitmux_policy_t *result = NULL; - test_assert(cmux != NULL); + tt_assert(cmux != NULL); if (cmux) { if (cmux == mock_cgp_tgt_1) result = mock_cgp_val_1; else if (cmux == mock_cgp_tgt_2) result = mock_cgp_val_2; @@ -342,11 +342,11 @@ test_scheduler_channel_states(void *arg) */ MOCK(scheduler_run, scheduler_run_noop_mock); - test_eq(smartlist_len(channels_pending), 0); + tt_int_op(smartlist_len(channels_pending), ==, 0); /* Set up a fake channel */ ch1 = new_fake_channel(); - test_assert(ch1); + tt_assert(ch1); /* Start it off in OPENING */ ch1->state = CHANNEL_STATE_OPENING; @@ -354,70 +354,70 @@ test_scheduler_channel_states(void *arg) ch1->cmux = circuitmux_alloc(); /* Try to register it */ channel_register(ch1); - test_assert(ch1->registered); + tt_assert(ch1->registered); /* It should start off in SCHED_CHAN_IDLE */ - test_eq(ch1->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_IDLE); /* Now get another one */ ch2 = new_fake_channel(); - test_assert(ch2); + tt_assert(ch2); ch2->state = CHANNEL_STATE_OPENING; ch2->cmux = circuitmux_alloc(); channel_register(ch2); - test_assert(ch2->registered); + tt_assert(ch2->registered); /* Send it to SCHED_CHAN_WAITING_TO_WRITE */ scheduler_channel_has_waiting_cells(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_WAITING_TO_WRITE); /* This should send it to SCHED_CHAN_PENDING */ scheduler_channel_wants_writes(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 1); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 1); /* Now send ch2 to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* Drop ch2 back to idle */ scheduler_channel_doesnt_want_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_IDLE); /* ...and back to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* ...and this should kick ch2 into SCHED_CHAN_PENDING */ scheduler_channel_has_waiting_cells(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* This should send ch2 to SCHED_CHAN_WAITING_TO_WRITE */ scheduler_channel_doesnt_want_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); - test_eq(smartlist_len(channels_pending), 1); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_TO_WRITE); + tt_int_op(smartlist_len(channels_pending), ==, 1); /* ...and back to SCHED_CHAN_PENDING */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* Now we exercise scheduler_touch_channel */ old_count = scheduler_compare_channels_mock_ctr; scheduler_touch_channel(ch1); - test_assert(scheduler_compare_channels_mock_ctr > old_count); + tt_assert(scheduler_compare_channels_mock_ctr > old_count); /* Close */ channel_mark_for_close(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSING); channel_mark_for_close(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSING); channel_closed(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSED); ch1 = NULL; channel_closed(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSED); ch2 = NULL; /* Shut things down */ @@ -474,20 +474,20 @@ test_scheduler_compare_channels(void *arg) /* Equal-channel case */ result = scheduler_compare_channels(&c1, &c1); - test_eq(result, 0); + tt_int_op(result, ==, 0); /* Distinct channels, distinct policies */ result = scheduler_compare_channels(&c1, &c2); - test_eq(result, -1); + tt_int_op(result, ==, -1); result = scheduler_compare_channels(&c2, &c1); - test_eq(result, 1); + tt_int_op(result, ==, 1); /* Distinct channels, same policy */ mock_cgp_val_2 = mock_cgp_val_1; result = scheduler_compare_channels(&c1, &c2); - test_eq(result, -1); + tt_int_op(result, ==, -1); result = scheduler_compare_channels(&c2, &c1); - test_eq(result, 1); + tt_int_op(result, ==, 1); done: @@ -512,24 +512,24 @@ test_scheduler_initfree(void *arg) { (void)arg; - test_eq(channels_pending, NULL); - test_eq(run_sched_ev, NULL); + tt_ptr_op(channels_pending, ==, NULL); + tt_ptr_op(run_sched_ev, ==, NULL); mock_event_init(); MOCK(tor_libevent_get_base, tor_libevent_get_base_mock); scheduler_init(); - test_assert(channels_pending != NULL); - test_assert(run_sched_ev != NULL); + tt_assert(channels_pending != NULL); + tt_assert(run_sched_ev != NULL); scheduler_free_all(); UNMOCK(tor_libevent_get_base); mock_event_free_all(); - test_eq(channels_pending, NULL); - test_eq(run_sched_ev, NULL); + tt_ptr_op(channels_pending, ==, NULL); + tt_ptr_op(run_sched_ev, ==, NULL); done: return; @@ -558,11 +558,11 @@ test_scheduler_loop(void *arg) */ MOCK(scheduler_run, scheduler_run_noop_mock); - test_eq(smartlist_len(channels_pending), 0); + tt_int_op(smartlist_len(channels_pending), ==, 0); /* Set up a fake channel */ ch1 = new_fake_channel(); - test_assert(ch1); + tt_assert(ch1); /* Start it off in OPENING */ ch1->state = CHANNEL_STATE_OPENING; @@ -570,53 +570,53 @@ test_scheduler_loop(void *arg) ch1->cmux = circuitmux_alloc(); /* Try to register it */ channel_register(ch1); - test_assert(ch1->registered); + tt_assert(ch1->registered); /* Finish opening it */ channel_change_state(ch1, CHANNEL_STATE_OPEN); /* It should start off in SCHED_CHAN_IDLE */ - test_eq(ch1->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_IDLE); /* Now get another one */ ch2 = new_fake_channel(); - test_assert(ch2); + tt_assert(ch2); ch2->state = CHANNEL_STATE_OPENING; ch2->cmux = circuitmux_alloc(); channel_register(ch2); - test_assert(ch2->registered); + tt_assert(ch2->registered); /* * Don't open ch2; then channel_num_cells_writeable() will return * zero and we'll get coverage of that exception case in scheduler_run() */ - test_eq(ch1->state, CHANNEL_STATE_OPEN); - test_eq(ch2->state, CHANNEL_STATE_OPENING); + tt_int_op(ch1->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch2->state, ==, CHANNEL_STATE_OPENING); /* Send it to SCHED_CHAN_WAITING_TO_WRITE */ scheduler_channel_has_waiting_cells(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_TO_WRITE); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_WAITING_TO_WRITE); /* This should send it to SCHED_CHAN_PENDING */ scheduler_channel_wants_writes(ch1); - test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 1); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 1); /* Now send ch2 to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* Drop ch2 back to idle */ scheduler_channel_doesnt_want_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_IDLE); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_IDLE); /* ...and back to SCHED_CHAN_WAITING_FOR_CELLS */ scheduler_channel_wants_writes(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* ...and this should kick ch2 into SCHED_CHAN_PENDING */ scheduler_channel_has_waiting_cells(ch2); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* * Now we've got two pending channels and need to fire off @@ -634,11 +634,11 @@ test_scheduler_loop(void *arg) * Assert that they're still in the states we left and aren't still * pending */ - test_eq(ch1->state, CHANNEL_STATE_OPEN); - test_eq(ch2->state, CHANNEL_STATE_OPENING); - test_assert(ch1->scheduler_state != SCHED_CHAN_PENDING); - test_assert(ch2->scheduler_state != SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 0); + tt_int_op(ch1->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch2->state, ==, CHANNEL_STATE_OPENING); + tt_assert(ch1->scheduler_state != SCHED_CHAN_PENDING); + tt_assert(ch2->scheduler_state != SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 0); /* Now, finish opening ch2, and get both back to pending */ channel_change_state(ch2, CHANNEL_STATE_OPEN); @@ -646,11 +646,11 @@ test_scheduler_loop(void *arg) scheduler_channel_wants_writes(ch2); scheduler_channel_has_waiting_cells(ch1); scheduler_channel_has_waiting_cells(ch2); - test_eq(ch1->state, CHANNEL_STATE_OPEN); - test_eq(ch2->state, CHANNEL_STATE_OPEN); - test_eq(ch1->scheduler_state, SCHED_CHAN_PENDING); - test_eq(ch2->scheduler_state, SCHED_CHAN_PENDING); - test_eq(smartlist_len(channels_pending), 2); + tt_int_op(ch1->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch2->state, ==, CHANNEL_STATE_OPEN); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_PENDING); + tt_int_op(smartlist_len(channels_pending), ==, 2); /* Now, set up the channel_flush_some_cells() mock */ MOCK(channel_flush_some_cells, channel_flush_some_cells_mock); @@ -680,24 +680,24 @@ test_scheduler_loop(void *arg) * ch1 should have gone to SCHED_CHAN_WAITING_FOR_CELLS, with 16 flushed * and 32 writeable. */ - test_eq(ch1->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch1->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* * ...ch2 should also have gone to SCHED_CHAN_WAITING_FOR_CELLS, with * channel_more_to_flush() returning false and channel_num_cells_writeable() * > 0/ */ - test_eq(ch2->scheduler_state, SCHED_CHAN_WAITING_FOR_CELLS); + tt_int_op(ch2->scheduler_state, ==, SCHED_CHAN_WAITING_FOR_CELLS); /* Close */ channel_mark_for_close(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSING); channel_mark_for_close(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSING); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSING); channel_closed(ch1); - test_eq(ch1->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch1->state, ==, CHANNEL_STATE_CLOSED); ch1 = NULL; channel_closed(ch2); - test_eq(ch2->state, CHANNEL_STATE_CLOSED); + tt_int_op(ch2->state, ==, CHANNEL_STATE_CLOSED); ch2 = NULL; /* Shut things down */ @@ -729,22 +729,22 @@ test_scheduler_queue_heuristic(void *arg) /* Not yet inited case */ scheduler_update_queue_heuristic(now - 180); - test_eq(queue_heuristic, 0); - test_eq(queue_heuristic_timestamp, now - 180); + tt_int_op(queue_heuristic, ==, 0); + tt_int_op(queue_heuristic_timestamp, ==, now - 180); queue_heuristic = 1000000000L; queue_heuristic_timestamp = now - 120; scheduler_update_queue_heuristic(now - 119); - test_eq(queue_heuristic, 500000000L); - test_eq(queue_heuristic_timestamp, now - 119); + tt_int_op(queue_heuristic, ==, 500000000L); + tt_int_op(queue_heuristic_timestamp, ==, now - 119); scheduler_update_queue_heuristic(now - 116); - test_eq(queue_heuristic, 62500000L); - test_eq(queue_heuristic_timestamp, now - 116); + tt_int_op(queue_heuristic, ==, 62500000L); + tt_int_op(queue_heuristic_timestamp, ==, now - 116); qh = scheduler_get_queue_heuristic(); - test_eq(qh, 0); + tt_int_op(qh, ==, 0); done: return;

1 0

← Newer
1
2
3
4
5
6
7
...
96
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits November 2014