static void
test_delete_timer_event() {
init_timer();
will_return_count( mock_clock_gettime, 0, -1 );
char user_data_1[] = "1";
char user_data_2[] = "2";
struct itimerspec interval;
interval.it_value.tv_sec = 1;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = 1;
interval.it_interval.tv_nsec = 0;
assert_true( add_timer_event_callback( &interval, mock_timer_event_callback, user_data_1 ) );
interval.it_value.tv_sec = 2;
interval.it_interval.tv_sec = 2;
assert_true( add_timer_event_callback( &interval, mock_timer_event_callback, user_data_2 ) );
delete_timer_event( mock_timer_event_callback, user_data_1 );
timer_callback_info *callback = find_timer_callback( mock_timer_event_callback );
assert_true( callback != NULL );
assert_true( callback->user_data == user_data_2 );
delete_timer_event( mock_timer_event_callback, user_data_2 );
assert_true( find_timer_callback( mock_timer_event_callback ) == NULL );
finalize_timer();
}
static void
test_timer_event_callback() {
init_timer();
will_return_count( mock_clock_gettime, 0, -1 );
char user_data[] = "It's time!!!";
struct itimerspec interval;
interval.it_value.tv_sec = 1;
interval.it_value.tv_nsec = 1000;
interval.it_interval.tv_sec = 2;
interval.it_interval.tv_nsec = 2000;
assert_true( add_timer_event_callback( &interval, mock_timer_event_callback, user_data ) );
timer_callback_info *callback = find_timer_callback( mock_timer_event_callback );
assert_true( callback != NULL );
assert_true( callback->function == mock_timer_event_callback );
assert_string_equal( callback->user_data, "It's time!!!" );
assert_int_equal( callback->interval.tv_sec, 2 );
assert_int_equal( callback->interval.tv_nsec, 2000 );
delete_timer_event( mock_timer_event_callback, user_data );
assert_true( find_timer_callback( mock_timer_event_callback ) == NULL );
finalize_timer();
}
static void
test_secure_channel_listen_start_listen_failed() {
setup();
int listen_fd = 1;
listener_info.listen_fd = -1;
expect_value( mock_socket, domain, PF_INET );
expect_value( mock_socket, type, SOCK_STREAM );
expect_value( mock_socket, protocol, 0 );
will_return( mock_socket, listen_fd );
expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
expect_value_count( mock_setsockopt, level, SOL_SOCKET, 1 );
expect_value_count( mock_setsockopt, optname, SO_REUSEADDR, 1 );
expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
will_return_count( mock_setsockopt, 0, 1 );
expect_value_count( mock_setsockopt, sockfd, listen_fd, 1 );
expect_value_count( mock_setsockopt, level, IPPROTO_TCP, 1 );
expect_value_count( mock_setsockopt, optname, TCP_NODELAY, 1 );
expect_not_value_count( mock_setsockopt, optval, NULL, 1 );
expect_value_count( mock_setsockopt, optlen, sizeof( int ), 1 );
will_return_count( mock_setsockopt, 0, 1 );
expect_value( mock_bind, sockfd, listen_fd );
expect_not_value( mock_bind, addr_in, NULL );
expect_value( mock_bind, addrlen, sizeof( struct sockaddr_in ) );
expect_value( mock_bind, sin_family32, AF_INET );
expect_value( mock_bind, sin_port32, ( uint32_t ) htons( OFP_TCP_PORT ) );
expect_value( mock_bind, addr_in->sin_addr.s_addr, htonl( INADDR_ANY ) );
will_return( mock_bind, 0 );
expect_value( mock_listen, sockfd, listen_fd );
expect_value( mock_listen, backlog, 128 );
will_return( mock_listen, -1 );
expect_value( mock_close, fd, listen_fd );
will_return_void( mock_close );
assert_false( secure_channel_listen_start( &listener_info ) );
assert_true( listener_info.listen_fd == -1 );
teardown();
}
static void test__createReaderGang(void **state)
{
int segmentCount = TOTOAL_SEGMENTS;
int ftsVersion = 1;
PGconn *conn = &pgconn;
const char *portalName = "portal1";
int motionListener = 10000;
int qePid = 2000;
int i = 0;
will_return(IsTransactionOrTransactionBlock, true);
will_return_count(getgpsegmentCount, segmentCount, -1);
will_return_count(getFtsVersion, ftsVersion, 1);
expect_any_count(isSockAlive, sock, -1);
will_return_count(isSockAlive, true, -1);
mockLibpq(conn, motionListener, qePid);
cdbgang_setAsync(false);
Gang * gang = AllocateReaderGang(GANGTYPE_PRIMARY_READER, portalName);
/* validate gang */
assert_int_equal(gang->size, TOTOAL_SEGMENTS);
assert_int_equal(gang->gang_id, 2);
assert_string_equal(gang->portal_name, portalName);
assert_int_equal(gang->type, GANGTYPE_PRIMARY_READER);
assert_int_equal(gang->noReuse, false);
assert_int_equal(gang->dispatcherActive, false);
assert_int_equal(gang->allocated, true);
for (i = 0; i < gang->size; i++)
{
SegmentDatabaseDescriptor *segdb = &gang->db_descriptors[i];
CdbComponentDatabaseInfo *cdbinfo = segdb->segment_database_info;
assert_int_equal(segdb->backendPid, qePid);
assert_int_equal(segdb->conn, conn);
assert_int_equal(segdb->errcode, 0);
assert_int_equal(segdb->error_message.len, 0);
assert_int_equal(segdb->motionListener, motionListener);
assert_int_equal(segdb->myAgent, NULL);
assert_int_equal(segdb->segindex, i);
validateCdbInfo(segdb->segment_database_info, segdb->segindex);
}
}
void
test__aocs_addcol_init(void **state)
{
AOCSAddColumnDesc desc;
RelationData reldata;
FormData_pg_appendonly pgappendonly;
int nattr = 5;
StdRdOptions **opts =
(StdRdOptions **) malloc(sizeof(StdRdOptions *) * nattr);
/* 3 existing columns */
opts[0] = opts[1] = opts[2] = (StdRdOptions *) NULL;
/* 2 newly added columns */
opts[3] = (StdRdOptions *) malloc(sizeof(StdRdOptions));
strcpy(opts[3]->compresstype, "rle_type");
opts[3]->compresslevel = 2;
opts[3]->blocksize = 8192;
opts[4] = (StdRdOptions *) malloc(sizeof(StdRdOptions));
strcpy(opts[4]->compresstype, "none");
opts[4]->compresslevel = 0;
opts[4]->blocksize = 8192 * 2;
/* One call to RelationGetAttributeOptions() */
expect_any(RelationGetAttributeOptions, rel);
will_return(RelationGetAttributeOptions, opts);
/* Two calls to create_datumstreamwrite() */
expect_string(create_datumstreamwrite, compName, "rle_type");
expect_string(create_datumstreamwrite, compName, "none");
expect_value(create_datumstreamwrite, compLevel, 2);
expect_value(create_datumstreamwrite, compLevel, 0);
expect_value_count(create_datumstreamwrite, checksum, true, 2);
expect_value_count(create_datumstreamwrite, safeFSWriteSize, 0, 2);
expect_value(create_datumstreamwrite, maxsz, 8192);
expect_value(create_datumstreamwrite, maxsz, 8192 * 2);
expect_value(create_datumstreamwrite, needsWAL, true);
expect_value(create_datumstreamwrite, needsWAL, true);
expect_any_count(create_datumstreamwrite, attr, 2);
expect_any_count(create_datumstreamwrite, relname, 2);
expect_any_count(create_datumstreamwrite, title, 2);
will_return_count(create_datumstreamwrite, NULL, 2);
pgappendonly.checksum = true;
FormData_pg_class rel;
rel.relpersistence = RELPERSISTENCE_PERMANENT;
reldata.rd_rel = &rel;
reldata.rd_appendonly = &pgappendonly;
reldata.rd_att = (TupleDesc) malloc(sizeof(struct tupleDesc));
reldata.rd_att->attrs =
(Form_pg_attribute *) malloc(sizeof(Form_pg_attribute *) * nattr);
memset(reldata.rd_att->attrs, 0, sizeof(Form_pg_attribute *) * nattr);
reldata.rd_att->natts = 5;
/* 3 existing columns, 2 new columns */
desc = aocs_addcol_init(&reldata, 2);
assert_int_equal(desc->num_newcols, 2);
assert_int_equal(desc->cur_segno, -1);
}
static void
test_clock_gettime_fail_einval() {
init_timer();
char user_data[] = "It's time!!!";
will_return_count( mock_clock_gettime, -1, -1 );
assert_false( add_periodic_event_callback( 1, mock_timer_event_callback, user_data ) );
finalize_timer();
}
static void
test_add_timer_event_callback_fail_with_invalid_timespec() {
init_timer();
will_return_count( mock_clock_gettime, 0, -1 );
char user_data[] = "It's time!!!";
struct itimerspec interval;
interval.it_value.tv_sec = 0;
interval.it_value.tv_nsec = 0;
interval.it_interval.tv_sec = 0;
interval.it_interval.tv_nsec = 0;
assert_false( add_timer_event_callback( &interval, mock_timer_event_callback, user_data ) );
finalize_timer();
}
/*
* Test cdbdisp_makeResult would return NULL if OOM happens
*/
void
test__cdbdisp_makeResult__oom(void **state)
{
CdbDispatchResult *result = NULL;
struct CdbDispatchResults *results = _init_cdbdisp_makeResult();
struct SegmentDatabaseDescriptor *segdbDesc =
(struct SegmentDatabaseDescriptor *) palloc0(sizeof(struct SegmentDatabaseDescriptor));
/*
* createPQExpBuffer is supposed to return NULL in OOM cases
*/
will_return_count(createPQExpBuffer, NULL, -1);
expect_any_count(destroyPQExpBuffer, str, -1);
will_be_called_count(destroyPQExpBuffer, -1);
result = cdbdisp_makeResult(results, segdbDesc, 0);
assert_true(result == NULL);
}
/*
* Checks if RedZoneHandler_ShmemInit() properly initializes the global variables
* as the postmaster
*/
void
test__RedZoneHandler_ShmemInit__InitializesGlobalVarsWhenPostmaster(void **state)
{
vmemTrackerInited = false;
IsUnderPostmaster = false;
/* Assign weird value to test the re-initialization */
fakeIsRunawayDetector = 1234;
isRunawayDetector = NULL;
expect_any_count(ShmemInitStruct, name, 2);
expect_any_count(ShmemInitStruct, size, 2);
expect_any_count(ShmemInitStruct, foundPtr, 2);
will_assign_value(ShmemInitStruct, foundPtr, false);
will_assign_value(ShmemInitStruct, foundPtr, false);
will_return_count(ShmemInitStruct, &fakeIsRunawayDetector, 2);
/*
* When vmem limit is not activated or runaway_detector_activation_percent is
* set to 0,, red zone should be very high (i.e., red-zone will be disabled).
* Note, it doesn't matter what runaway_detector_activation_percent is set for
* this test, as the VmemTracker_ConvertVmemMBToChunks is returning 0.
*/
will_return(VmemTracker_ConvertVmemMBToChunks, 0);
expect_any(VmemTracker_ConvertVmemMBToChunks, mb);
RedZoneHandler_ShmemInit();
assert_true(isRunawayDetector == &fakeIsRunawayDetector);
assert_true(redZoneChunks == INT32_MAX);
assert_true(*isRunawayDetector == 0);
/*
* When the activation percent is set to 100, we will not even attempt calculating
* the redZoneChunks and instead assign INT32_MAX directly. Note, we don't even
* call VmemTracker_ConvertVmemMBToChunks()
*/
runaway_detector_activation_percent = 100;
redZoneChunks = 0;
RedZoneHandler_ShmemInit();
assert_true(redZoneChunks == INT32_MAX);
}
static void
test_periodic_event_callback() {
init_timer();
char user_data[] = "It's time!!!";
will_return_count( mock_clock_gettime, 0, -1 );
assert_true( add_periodic_event_callback( 1, mock_timer_event_callback, user_data ) );
timer_callback_info *callback = find_timer_callback( mock_timer_event_callback );
assert_true( callback != NULL );
assert_true( callback->function == mock_timer_event_callback );
assert_string_equal( callback->user_data, "It's time!!!" );
assert_int_equal( callback->interval.tv_sec, 1 );
assert_int_equal( callback->interval.tv_nsec, 0 );
delete_timer_event( mock_timer_event_callback, user_data );
assert_true( find_timer_callback( mock_timer_event_callback ) == NULL );
finalize_timer();
}
static void
test_send_then_message_received_callback_is_called() {
init_messenger( "/tmp" );
will_return_count( mock_clock_gettime, 0, -1 );
const char service_name[] = "Say HELLO";
expect_value( callback_hello, tag, 43556 );
expect_string( callback_hello, data, "HELLO" );
expect_value( callback_hello, len, 6 );
add_message_received_callback( service_name, callback_hello );
send_message( service_name, 43556, "HELLO", strlen( "HELLO" ) + 1 );
start_messenger();
delete_message_received_callback( service_name, callback_hello );
delete_send_queue( lookup_hash_entry( send_queues, service_name ) );
finalize_messenger();
}
void mockLibpq(PGconn *pgConn, int motionListener, int qePid)
{
expect_any_count(PQconnectdbParams, keywords, -1);
expect_any_count(PQconnectdbParams, values, -1);
expect_any_count(PQconnectdbParams, expand_dbname, -1);
will_return_count(PQconnectdbParams, pgConn, TOTOAL_SEGMENTS);
expect_value_count(PQstatus, conn, pgConn, -1);
will_return_count(PQstatus, CONNECTION_OK, -1);
expect_value_count(PQsocket, conn, pgConn, -1);
will_return_count(PQsocket, 100, -1);
expect_value_count(PQsetNoticeReceiver, conn, pgConn, -1);
expect_any_count(PQsetNoticeReceiver, proc, -1);
expect_any_count(PQsetNoticeReceiver, arg, -1);
will_return_count(PQsetNoticeReceiver, CONNECTION_OK, -1);
expect_value_count(PQgetQEdetail, conn, pgConn, -1);
will_return_count(PQgetQEdetail, motionListener, -1);
expect_value_count(PQbackendPID, conn, pgConn, -1);
will_return_count(PQbackendPID, qePid, -1);
}
