acbb59f50d5196facde837ea377f70e98ce1e6f8Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#include <talloc.h>

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#include <tevent.h>

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#include <errno.h>

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser#include <popt.h>

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser#include <time.h>

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber#include "providers/dp_backend.h"

ae0aeadeaab6b2535952dd699efdf889c4f7464fStéphane Graber#include "providers/dp_ptask_private.h"

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser#include "providers/dp_ptask.h"

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser#include "tests/cmocka/common_mock.h"

207bf0e475f1dc6e9a2dac2cee3a209b56427855Stéphane Graber#include "tests/cmocka/common_mock_be.h"

207bf0e475f1dc6e9a2dac2cee3a209b56427855Stéphane Graber#include "tests/common.h"

207bf0e475f1dc6e9a2dac2cee3a209b56427855Stéphane Graber

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#define DELAY 2

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#define PERIOD 1

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#define TIMEOUT 123

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn#define new_test(test) \

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn cmocka_unit_test_setup_teardown(test_ ## test, test_setup, test_teardown)

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallynstruct test_ctx {

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn struct sss_test_ctx *tctx;

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn struct be_ctx *be_ctx;

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn time_t when;

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn bool done;

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn bool add_online_cb_called;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn bool add_offline_cb_called;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn};

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#define mark_online(test_ctx) do { \

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx->be_ctx->offstat.went_offline = 0; \

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx->be_ctx->offstat.offline = false; \

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn} while (0)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn#define mark_offline(test_ctx) do { \

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx->be_ctx->offstat.went_offline = get_current_time(); \

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx->be_ctx->offstat.offline = true; \

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn} while (0)

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn#define is_sync_ptask_finished(test_ctx, ptask) \

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber (test_ctx->done && ptask->req == NULL)

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graberstatic time_t get_current_time(void)

9313e1e628160ca64f9e7fcec6500056c9a0725fStéphane Graber{

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber struct timeval tv;

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber int ret;

f02ce27d4b1a9d01b88d0ffaf626e5bafa671bf0Stéphane Graber

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber ret = gettimeofday(&tv, NULL);

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber assert_int_equal(0, ret);

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber return tv.tv_sec;

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber}

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graberbool be_is_offline(struct be_ctx *ctx)

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber{

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber return ctx->offstat.offline;

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn}

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graberint be_add_online_cb(TALLOC_CTX *mem_ctx,

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber struct be_ctx *ctx,

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber be_callback_t cb,

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber void *pvt,

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber struct be_cb **online_cb)

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber{

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber struct test_ctx *test_ctx = NULL;

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber

bf7d76cf3ae180820c0a29e0bfbaa97c20ce6a3dSerge Hallyn test_ctx = sss_mock_ptr_type(struct test_ctx *);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx->add_online_cb_called = true;

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber return ERR_OK;

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber}

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graber

f2a95ee1bf54c949614a68bf152ea9a8e1d3a172Stéphane Graberint be_add_offline_cb(TALLOC_CTX *mem_ctx,

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn struct be_ctx *ctx,

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber be_callback_t cb,

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber void *pvt,

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber struct be_cb **offline_cb)

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber{

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber struct test_ctx *test_ctx = NULL;

17abf2784de1047fb2904ff130ee5efe4ea7b598Elan Ruusamäe

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber test_ctx = sss_mock_ptr_type(struct test_ctx *);

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber test_ctx->add_offline_cb_called = true;

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber return ERR_OK;

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber}

0a3673e80732ab83d807d406fb2fd3c3b7f54ad3Stéphane Graber

542939c31bb73bab55f2fd71243b98f5559597d1Stéphane Graberstruct test_be_ptask_state {

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn struct test_ctx *test_ctx;

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn};

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn

5ff337745e4a705293b056ab58f6ea7a92cabbc8Stéphane Graberstruct tevent_req * test_be_ptask_send(TALLOC_CTX *mem_ctx,

68c36a303f402b52f94067d3da7b168e274001a7Serge Hallyn struct tevent_context *ev,

5ff337745e4a705293b056ab58f6ea7a92cabbc8Stéphane Graber struct be_ctx *be_ctx,

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn struct be_ptask *be_ptask,

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn void *pvt)

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_be_ptask_state *state = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct tevent_req *req = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(ev);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(be_ctx);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn assert_non_null(be_ptask);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn assert_non_null(pvt);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn test_ctx = talloc_get_type(pvt, struct test_ctx);

1897e3bcd36af9f3fe6d3649910a9adb93e5e988Serge Hallyn assert_non_null(test_ctx);

3f5f5d99b0ea1c204699b13d4a0caf4d9e745449Stéphane Graber

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn test_ctx->when = get_current_time();

52c8f624b5f9ef665f33a7aa80e0aa18b91daa4aSerge Hallyn

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser req = tevent_req_create(mem_ctx, &state, struct test_be_ptask_state);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn assert_non_null(req);

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser state->test_ctx = test_ctx;

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn tevent_req_done(req);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn tevent_req_post(req, ev);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn return req;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn}

5d066f24e65ef482cdfee241ce65e060d1652efcScott Moser

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallynstruct tevent_req * test_be_ptask_null_send(TALLOC_CTX *mem_ctx,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct tevent_context *ev,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct be_ctx *be_ctx,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct be_ptask *be_ptask,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn void *pvt)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn struct test_ctx *test_ctx = NULL;

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn assert_non_null(ev);

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser assert_non_null(be_ctx);

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser assert_non_null(be_ptask);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(pvt);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser test_ctx = talloc_get_type(pvt, struct test_ctx);

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser assert_non_null(test_ctx);

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser test_ctx->when = get_current_time();

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser test_ctx->done = true;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn return NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn}

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallynstruct tevent_req * test_be_ptask_timeout_send(TALLOC_CTX *mem_ctx,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct tevent_context *ev,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct be_ctx *be_ctx,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct be_ptask *be_ptask,

ed4616b1cfbc84dd01caa8546d813e8c5d482921Christian Bühler void *pvt)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_be_ptask_state *state = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct tevent_req *req = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

3eecde703e9ac3af788ac17357f378d6b6d7c658Serge Hallyn assert_non_null(ev);

b8bced69a80a8be95fdbbb6b4e9ad7fa85464b1eSerge Hallyn assert_non_null(be_ctx);

3eecde703e9ac3af788ac17357f378d6b6d7c658Serge Hallyn assert_non_null(be_ptask);

3eecde703e9ac3af788ac17357f378d6b6d7c658Serge Hallyn assert_non_null(pvt);

8a63c0a9d9089e6365e5a696455476febed39d6aStéphane Graber

8a3c76b24d73ab8a830035e7a66400e2cc2e8334Stéphane Graber test_ctx = talloc_get_type(pvt, struct test_ctx);

8a3c76b24d73ab8a830035e7a66400e2cc2e8334Stéphane Graber assert_non_null(test_ctx);

8a3c76b24d73ab8a830035e7a66400e2cc2e8334Stéphane Graber

8a3c76b24d73ab8a830035e7a66400e2cc2e8334Stéphane Graber test_ctx->when = get_current_time();

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn req = tevent_req_create(mem_ctx, &state, struct test_be_ptask_state);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(req);

52c8f624b5f9ef665f33a7aa80e0aa18b91daa4aSerge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn state->test_ctx = test_ctx;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn /* we won't finish the request */

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov return req;

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser}

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallynerrno_t test_be_ptask_recv(struct tevent_req *req)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn struct test_be_ptask_state *state = NULL;

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn state = tevent_req_data(req, struct test_be_ptask_state);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn assert_non_null(state);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn state->test_ctx->done = true;

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

52c8f624b5f9ef665f33a7aa80e0aa18b91daa4aSerge Hallyn TEVENT_REQ_RETURN_ON_ERROR(req);

427bffc7a10c9015dc78ef52543f7b8cb9414359Serge Hallyn

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser return ERR_OK;

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser}

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Mosererrno_t test_be_ptask_error_recv(struct tevent_req *req)

5d066f24e65ef482cdfee241ce65e060d1652efcScott Moser{

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser struct test_be_ptask_state *state = NULL;

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn state = tevent_req_data(req, struct test_be_ptask_state);

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn assert_non_null(state);

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn state->test_ctx->done = true;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn return ERR_INTERNAL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn}

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Mosererrno_t test_be_ptask_sync(TALLOC_CTX *mem_ctx,

3eecde703e9ac3af788ac17357f378d6b6d7c658Serge Hallyn struct tevent_context *ev,

52c8f624b5f9ef665f33a7aa80e0aa18b91daa4aSerge Hallyn struct be_ctx *be_ctx,

52c8f624b5f9ef665f33a7aa80e0aa18b91daa4aSerge Hallyn struct be_ptask *be_ptask,

52c8f624b5f9ef665f33a7aa80e0aa18b91daa4aSerge Hallyn void *pvt)

17abf2784de1047fb2904ff130ee5efe4ea7b598Elan Ruusamäe{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(ev);

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser assert_non_null(be_ctx);

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser assert_non_null(be_ptask);

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser assert_non_null(pvt);

d46417540f61ffb93344f3d338340588bf118ab4Stéphane Graber

d46417540f61ffb93344f3d338340588bf118ab4Stéphane Graber test_ctx = talloc_get_type(pvt, struct test_ctx);

d46417540f61ffb93344f3d338340588bf118ab4Stéphane Graber assert_non_null(test_ctx);

d46417540f61ffb93344f3d338340588bf118ab4Stéphane Graber

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser test_ctx->when = get_current_time();

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser test_ctx->done = true;

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn return ERR_OK;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn}

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkoverrno_t test_be_ptask_sync_error(TALLOC_CTX *mem_ctx,

427bffc7a10c9015dc78ef52543f7b8cb9414359Serge Hallyn struct tevent_context *ev,

427bffc7a10c9015dc78ef52543f7b8cb9414359Serge Hallyn struct be_ctx *be_ctx,

427bffc7a10c9015dc78ef52543f7b8cb9414359Serge Hallyn struct be_ptask *be_ptask,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn void *pvt)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(ev);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(be_ctx);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(be_ptask);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(pvt);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx = talloc_get_type(pvt, struct test_ctx);

1881820ae4ff9004beef1bf7f04553580840441dSerge Hallyn assert_non_null(test_ctx);

1881820ae4ff9004beef1bf7f04553580840441dSerge Hallyn

1897e3bcd36af9f3fe6d3649910a9adb93e5e988Serge Hallyn test_ctx->when = get_current_time();

1897e3bcd36af9f3fe6d3649910a9adb93e5e988Serge Hallyn test_ctx->done = true;

853d58fdf5af0960b7b6edc9dea0fadddb8535f1Elan Ruusamäe

1897e3bcd36af9f3fe6d3649910a9adb93e5e988Serge Hallyn return ERR_INTERNAL;

1897e3bcd36af9f3fe6d3649910a9adb93e5e988Serge Hallyn}

1897e3bcd36af9f3fe6d3649910a9adb93e5e988Serge Hallyn

1881820ae4ff9004beef1bf7f04553580840441dSerge Hallynstatic int test_setup(void **state)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_true(leak_check_setup());

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx = talloc_zero(global_talloc_context, struct test_ctx);

6dc6f80bfd7cb169948f2ef9a95dcf6d2edee853Kevin Carter assert_non_null(test_ctx);

6dc6f80bfd7cb169948f2ef9a95dcf6d2edee853Kevin Carter

9cde0368fbbfa61add2e73f8ccd5b00c1b0f2e08Stéphane Graber test_ctx->tctx = create_ev_test_ctx(test_ctx);

6dc6f80bfd7cb169948f2ef9a95dcf6d2edee853Kevin Carter assert_non_null(test_ctx->tctx);

6dc6f80bfd7cb169948f2ef9a95dcf6d2edee853Kevin Carter

9cde0368fbbfa61add2e73f8ccd5b00c1b0f2e08Stéphane Graber test_ctx->be_ctx = mock_be_ctx(test_ctx, test_ctx->tctx);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_non_null(test_ctx->be_ctx);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn test_ctx->be_ctx->ev = tevent_context_init(test_ctx->be_ctx);

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov assert_non_null(test_ctx->be_ctx->ev);

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov check_leaks_push(test_ctx);

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov *state = test_ctx;

4b954f12173c382f7104a0e9464fa66dd3cade35Dimitri John Ledkov return 0;

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn}

b942e67226af9e690bd63ac440b99aedb6becbb3Scott Moser

4759162d078d86628956cae4846c6efccf548e67Serge Hallynstatic int test_teardown(void **state)

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser{

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser assert_true(check_leaks_pop(*state));

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser talloc_zfree(*state);

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser assert_true(leak_check_teardown());

ad3f14ab58ec91ff11d0dcf2cbd5f47f02935344Scott Moser return 0;

27c278a76931bfc4660caa85d1942ca91c86e0bfStéphane Graber}

4759162d078d86628956cae4846c6efccf548e67Serge Hallyn

4759162d078d86628956cae4846c6efccf548e67Serge Hallynvoid test_be_ptask_create_einval_be(void **state)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = (struct test_ctx *)(*state);

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn struct be_ptask *ptask = NULL;

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn errno_t ret;

b942e67226af9e690bd63ac440b99aedb6becbb3Scott Moser

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn ret = be_ptask_create(test_ctx, NULL, PERIOD, 0, 0, 0, 0,

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn test_be_ptask_recv, NULL, "Test ptask", &ptask);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_int_equal(ret, EINVAL);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_null(ptask);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn}

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallynvoid test_be_ptask_create_einval_period(void **state)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn struct test_ctx *test_ctx = (struct test_ctx *)(*state);

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn struct be_ptask *ptask = NULL;

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn errno_t ret;

27c278a76931bfc4660caa85d1942ca91c86e0bfStéphane Graber

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn ret = be_ptask_create(test_ctx, test_ctx->be_ctx, 0, 0, 0, 0, 0,

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn test_be_ptask_recv, NULL, "Test ptask", &ptask);

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn assert_int_equal(ret, EINVAL);

f1ccde27c038e7fb7e538913505248b36ddd9e65Serge Hallyn assert_null(ptask);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn}

3eecde703e9ac3af788ac17357f378d6b6d7c658Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallynvoid test_be_ptask_create_einval_send(void **state)

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn{

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn struct test_ctx *test_ctx = (struct test_ctx *)(*state);

27c278a76931bfc4660caa85d1942ca91c86e0bfStéphane Graber struct be_ptask *ptask = NULL;

2b142295afb3cac8c4be2a233e51ab5a9f7e10e9Serge Hallyn errno_t ret;

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn

27c278a76931bfc4660caa85d1942ca91c86e0bfStéphane Graber ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn BE_PTASK_OFFLINE_SKIP, 0, NULL,

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn test_be_ptask_recv, NULL, "Test ptask", &ptask);

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn assert_int_equal(ret, EINVAL);

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn assert_null(ptask);

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn}

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moservoid test_be_ptask_create_einval_recv(void **state)

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn{

17abf2784de1047fb2904ff130ee5efe4ea7b598Elan Ruusamäe struct test_ctx *test_ctx = (struct test_ctx *)(*state);

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn struct be_ptask *ptask = NULL;

17abf2784de1047fb2904ff130ee5efe4ea7b598Elan Ruusamäe errno_t ret;

1aad9e44d65e7c20dabc4c99f57bcf532db66c68Serge Hallyn

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

42ff5f0f8767114d060f5031055038a1a1c3759aSerge Hallyn BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn NULL, NULL, "Test ptask", &ptask);

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser assert_int_equal(ret, EINVAL);

65d8ae9c4a66f5ca85289c02dc06d63261c84619Scott Moser assert_null(ptask);

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn}

c01c25fcdd1e0cacad8075bcfcef4c8e8d4b8cb6Stéphane Graber

c01c25fcdd1e0cacad8075bcfcef4c8e8d4b8cb6Stéphane Grabervoid test_be_ptask_create_einval_name(void **state)

c01c25fcdd1e0cacad8075bcfcef4c8e8d4b8cb6Stéphane Graber{

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn struct test_ctx *test_ctx = (struct test_ctx *)(*state);

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn struct be_ptask *ptask = NULL;

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn errno_t ret;

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

2133f58c66ab7627a4159fafbb75106c556b014dSerge Hallyn BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

57d116ab501594c2e50ab45f1cf2fae48c5eab09Serge Hallyn test_be_ptask_recv, NULL, NULL, &ptask);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_int_equal(ret, EINVAL);

d1458ac8d13880f83fa2d1e08623b97c50d311d7Serge Hallyn assert_null(ptask);

b942e67226af9e690bd63ac440b99aedb6becbb3Scott Moser}

b942e67226af9e690bd63ac440b99aedb6becbb3Scott Moser

void test_be_ptask_create_no_delay(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now;

errno_t ret;

now = get_current_time();

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now <= ptask->last_execution);

assert_true(now <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_create_first_delay(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now;

errno_t ret;

now = get_current_time();

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, DELAY, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now + DELAY <= ptask->last_execution);

assert_true(now + DELAY <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_disable(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

be_ptask_disable(ptask);

assert_null(ptask->timer);

assert_false(ptask->enabled);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_enable(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now;

errno_t ret;

now = get_current_time();

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

be_ptask_disable(ptask);

now = get_current_time();

be_ptask_enable(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now <= ptask->last_execution);

assert_true(now <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_enable_delay(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, DELAY, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

be_ptask_disable(ptask);

test_ctx->done = false;

now = get_current_time();

be_ptask_enable(ptask);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now + DELAY <= ptask->last_execution);

assert_true(now + DELAY <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_offline_skip(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t next_execution;

time_t now;

errno_t ret;

mark_offline(test_ctx);

now = get_current_time();

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

next_execution = ptask->next_execution;

assert_true(now <= next_execution);

while (ptask->next_execution == next_execution && !test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(next_execution + PERIOD <= ptask->next_execution);

assert_true(ptask->enabled);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_offline_disable(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

errno_t ret;

mark_offline(test_ctx);

will_return(be_add_online_cb, test_ctx);

will_return(be_add_offline_cb, test_ctx);

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_DISABLE, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

assert_true(test_ctx->add_online_cb_called);

assert_true(test_ctx->add_offline_cb_called);

while (ptask->enabled && !test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_false(ptask->enabled);

assert_false(test_ctx->done);

assert_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_offline_execute(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

errno_t ret;

mark_offline(test_ctx);

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_EXECUTE, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(ptask->enabled);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_reschedule_ok(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t next_execution;

time_t now;

errno_t ret;

now = get_current_time();

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

next_execution = ptask->next_execution;

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now <= ptask->last_execution);

assert_true(now <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

assert_true(next_execution + PERIOD <= ptask->next_execution);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_reschedule_null(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now = 0;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_null_send,

test_be_ptask_recv, test_ctx, "Test ptask",

&ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

now = get_current_time();

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now + PERIOD <= ptask->next_execution);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_reschedule_error(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now = 0;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_error_recv, test_ctx, "Test ptask",

&ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

now = get_current_time();

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now + PERIOD <= ptask->next_execution);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_reschedule_timeout(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now = 0;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 1,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_timeout_send,

test_be_ptask_error_recv, test_ctx, "Test ptask",

&ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

/* first iterate until the task is executed */

while (!test_ctx->done && ptask->req == NULL) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

/* then iterate until the request is destroyed */

while (!test_ctx->done && ptask->req != NULL) {

now = get_current_time();

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_false(test_ctx->done);

assert_true(now + PERIOD <= ptask->next_execution);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_reschedule_backoff(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t next_execution;

time_t now_first;

time_t now_backoff = 0;

errno_t ret;

now_first = get_current_time();

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, PERIOD*2, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

/* first run */

next_execution = ptask->next_execution;

while (!test_ctx->done) {

/* We need to acquire timestamp for the second test here, since this

now_backoff = get_current_time();

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now_first <= ptask->last_execution);

assert_true(now_first <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

assert_true(next_execution + PERIOD <= ptask->next_execution);

assert_int_equal(PERIOD*2, ptask->period);

assert_non_null(ptask->timer);

test_ctx->done = false;

/* second run */

next_execution = ptask->next_execution;

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now_backoff + PERIOD <= ptask->last_execution);

assert_true(now_backoff + PERIOD <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

assert_true(next_execution + PERIOD*2 <= ptask->next_execution);

assert_int_equal(PERIOD*2, ptask->period);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_get_period(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t out_period;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

out_period = be_ptask_get_period(ptask);

assert_true(PERIOD == out_period);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_get_timeout(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t out_timeout;

errno_t ret;

ret = be_ptask_create(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, TIMEOUT,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_send,

test_be_ptask_recv, test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

out_timeout = be_ptask_get_timeout(ptask);

assert_true(TIMEOUT == out_timeout);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_create_sync(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now;

errno_t ret;

now = get_current_time();

ret = be_ptask_create_sync(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_sync,

test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!test_ctx->done) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now <= ptask->last_execution);

assert_true(now <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_sync_reschedule_ok(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t next_execution;

time_t now;

errno_t ret;

now = get_current_time();

ret = be_ptask_create_sync(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0, test_be_ptask_sync,

test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

next_execution = ptask->next_execution;

while (!is_sync_ptask_finished(test_ctx, ptask)) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now <= ptask->last_execution);

assert_true(now <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

assert_true(next_execution + PERIOD <= ptask->next_execution);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_sync_reschedule_error(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t now = 0;

errno_t ret;

ret = be_ptask_create_sync(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, 0,

test_be_ptask_sync_error,

test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

while (!is_sync_ptask_finished(test_ctx, ptask)) {

now = get_current_time();

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now + PERIOD <= ptask->next_execution);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

void test_be_ptask_sync_reschedule_backoff(void **state)

{

struct test_ctx *test_ctx = (struct test_ctx *)(*state);

struct be_ptask *ptask = NULL;

time_t next_execution;

time_t now_first;

time_t now_backoff = 0;

errno_t ret;

now_first = get_current_time();

ret = be_ptask_create_sync(test_ctx, test_ctx->be_ctx, PERIOD, 0, 0, 0, 0,

BE_PTASK_OFFLINE_SKIP, PERIOD*2,

test_be_ptask_sync_error,

test_ctx, "Test ptask", &ptask);

assert_int_equal(ret, ERR_OK);

assert_non_null(ptask);

assert_non_null(ptask->timer);

/* first run */

next_execution = ptask->next_execution;

while (!is_sync_ptask_finished(test_ctx, ptask)) {

/* We need to acquire timestamp for the second test here, since this

now_backoff = get_current_time();

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now_first <= ptask->last_execution);

assert_true(now_first <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

assert_true(next_execution + PERIOD <= ptask->next_execution);

assert_int_equal(PERIOD*2, ptask->period);

assert_non_null(ptask->timer);

test_ctx->done = false;

/* second run */

next_execution = ptask->next_execution;

while (!is_sync_ptask_finished(test_ctx, ptask)) {

tevent_loop_once(test_ctx->be_ctx->ev);

}

assert_true(now_backoff + PERIOD <= ptask->last_execution);

assert_true(now_backoff + PERIOD <= test_ctx->when);

assert_true(ptask->last_execution <= test_ctx->when);

assert_true(next_execution + PERIOD*2 <= ptask->next_execution);

assert_int_equal(PERIOD*2, ptask->period);

assert_non_null(ptask->timer);

be_ptask_destroy(&ptask);

assert_null(ptask);

}

int main(int argc, const char *argv[])

{

poptContext pc;

int opt;

struct poptOption long_options[] = {

POPT_AUTOHELP

SSSD_DEBUG_OPTS

POPT_TABLEEND

};

const struct CMUnitTest tests[] = {

new_test(be_ptask_create_einval_be),

new_test(be_ptask_create_einval_period),

new_test(be_ptask_create_einval_send),

new_test(be_ptask_create_einval_recv),

new_test(be_ptask_create_einval_name),

new_test(be_ptask_create_no_delay),

new_test(be_ptask_create_first_delay),

new_test(be_ptask_disable),

new_test(be_ptask_enable),

new_test(be_ptask_enable_delay),

new_test(be_ptask_offline_skip),

new_test(be_ptask_offline_disable),

new_test(be_ptask_offline_execute),

new_test(be_ptask_reschedule_ok),

new_test(be_ptask_reschedule_null),

new_test(be_ptask_reschedule_error),

new_test(be_ptask_reschedule_timeout),

new_test(be_ptask_reschedule_backoff),

new_test(be_ptask_get_period),

new_test(be_ptask_get_timeout),

new_test(be_ptask_create_sync),

new_test(be_ptask_sync_reschedule_ok),

new_test(be_ptask_sync_reschedule_error),

new_test(be_ptask_sync_reschedule_backoff)

};

/* Set debug level to invalid value so we can deside if -d 0 was used. */

debug_level = SSSDBG_INVALID;

pc = poptGetContext(argv[0], argc, argv, long_options, 0);

while((opt = poptGetNextOpt(pc)) != -1) {

switch(opt) {

default:

fprintf(stderr, "\nInvalid option %s: %s\n\n",

poptBadOption(pc, 0), poptStrerror(opt));

poptPrintUsage(pc, stderr, 0);

return 1;

}

}

poptFreeContext(pc);

DEBUG_CLI_INIT(debug_level);

return cmocka_run_group_tests(tests, NULL, NULL);

}