test_fossscheduler.c

Go to the documentation of this file.

/*
 SPDX-FileCopyrightText: © 2011 Hewlett-Packard Development Company, L.P.
 
 SPDX-License-Identifier: GPL-2.0-only
*/
 
/* includes for files that will be tested */
#include <libfossscheduler.h>
 
/* library includes */
#include <string.h>
#include <stdio.h>
#include <unistd.h>
 
/* cunit includes */
#include <libfocunit.h>
 
#ifndef COMMIT_HASH
#define COMMIT_HASH "COMMIT_HASH Unknown"
#endif
 
/* ************************************************************************** */
/* *** declaration of private members *************************************** */
/* ************************************************************************** */
 
extern int items_processed;
extern int valid;
extern int sscheduler;
extern int agent_verbose;
extern void fo_heartbeat();
 
/* ************************************************************************** */
/* *** set up and tear down for fossschduler ******************************** */
/* ************************************************************************** */
 
char tbuffer[1024];
int in_sub[2];
int out_sub[2];
int stdin_t;
int stdout_t;
FILE* read_from;
FILE* write_to;
 
#define FROM_UNIT "UNIT\n"
#define VERBOSE_TEST 7
#define NC_TEST "Not a Command\n"
 
#define write_con(...) \
  fprintf(write_to, __VA_ARGS__); \
  fflush(write_to);
 
void set_up(void)
{
  FO_ASSERT_TRUE_FATAL(!pipe(in_sub));
  FO_ASSERT_TRUE_FATAL(!pipe(out_sub));
 
  stdin_t = dup(fileno(stdin));
  stdout_t = dup(fileno(stdout));
 
  dup2(out_sub[1], fileno(stdout));
  dup2(in_sub[0], fileno(stdin));
  read_from = fdopen(out_sub[0], "rb");
  write_to = fdopen(in_sub[1], "wb");
 
  memset(tbuffer, '\0', sizeof(tbuffer));
}
 
void tear_down(void)
{
  fclose(read_from);
  fclose(write_to);
 
  close(in_sub[0]);
  close(in_sub[1]);
  close(out_sub[0]);
  close(out_sub[1]);
 
  dup2(stdin_t, fileno(stdin));
  dup2(stdout_t, fileno(stdout));
}
 
void signal_connect_end()
{
  FO_ASSERT_FALSE(valid);
  FO_ASSERT_STRING_EQUAL(fgets(tbuffer, sizeof(tbuffer), read_from), "OK\n");
 
  write_con("CLOSE\n");
}
 
void signal_connect_verbose()
{
  FO_ASSERT_FALSE(valid);
  FO_ASSERT_EQUAL(agent_verbose, VERBOSE_TEST);
 
  agent_verbose = 0;
 
  write_con("CLOSE\n");
}
 
void signal_connect_version()
{
  FO_ASSERT_FALSE(valid);
  FO_ASSERT_PTR_NOT_NULL(fgets(tbuffer, sizeof(tbuffer), read_from));
  tbuffer[strlen(tbuffer) - 1] = '\0';
  FO_ASSERT_STRING_EQUAL(tbuffer, COMMIT_HASH);
 
  write_con("CLOSE\n");
}
 
/* ************************************************************************** */
/* *** tests **************************************************************** */
/* ************************************************************************** */
 
void test_scheduler_no_connect()
{
  int argc = 2;
  char* argv[] = {"./test_clibs", "--config=./scheddata"};
 
  fo_scheduler_connect(&argc, argv, NULL);
 
  FO_ASSERT_FALSE(sscheduler);
  FO_ASSERT_EQUAL(items_processed, 0);
  FO_ASSERT_FALSE(valid);
  FO_ASSERT_FALSE(agent_verbose);
 
  /* make sure that fo_scheduler_connect didn't write anything to stdout */
  fprintf(stdout, FROM_UNIT);
  FO_ASSERT_PTR_NOT_NULL(fgets(tbuffer, sizeof(tbuffer), read_from));
  FO_ASSERT_STRING_EQUAL(tbuffer, FROM_UNIT);
 
  /* reset stdout for the next test */
  while (strcmp(tbuffer, FROM_UNIT) != 0)
    FO_ASSERT_PTR_NOT_NULL(fgets(tbuffer, sizeof(tbuffer), read_from));
}
 
void test_scheduler_connect()
{
  int argc = 2;
  char* argv[] = {"./test_clibs", "--config=./scheddata", "--scheduler_start"};
  char* tmp;
 
  fo_scheduler_connect(&argc, argv, NULL);
 
  FO_ASSERT_TRUE(sscheduler);
  FO_ASSERT_EQUAL(items_processed, 0);
  FO_ASSERT_FALSE(valid);
  FO_ASSERT_FALSE(agent_verbose);
 
  /* check that the correct stuff was written to stdout */
  memset(tbuffer, '\0', sizeof(tbuffer));
  tmp = fgets(tbuffer, sizeof(tbuffer), read_from);
  FO_ASSERT_PTR_NOT_NULL(tmp);
  FO_ASSERT_STRING_EQUAL(tbuffer, COMMIT_HASH);
 
  tmp = fgets(tbuffer, sizeof(tbuffer), read_from);
  FO_ASSERT_PTR_NOT_NULL(tmp);
  FO_ASSERT_STRING_EQUAL(tmp, "OK\n");
 
  ualarm(10, 0);
  usleep(20);
 
  FO_ASSERT_STRING_EQUAL(
    fgets(tbuffer, sizeof(tbuffer), read_from),
    "HEART: 0\n");
}
 
void test_scheduler_next_close()
{
  write_con("CLOSE\n");
 
  FO_ASSERT_PTR_NULL(fo_scheduler_next());
  FO_ASSERT_FALSE(valid);
}
 
void test_scheduler_next_end()
{
  write_con("END\n");
 
  signal(SIGALRM, signal_connect_end);
  ualarm(10, 0);
 
  FO_ASSERT_PTR_NULL(fo_scheduler_next());
  FO_ASSERT_FALSE(valid);
}
 
void test_scheduler_next_verbose()
{
  write_con("VERBOSE %d\n", VERBOSE_TEST);
 
  signal(SIGALRM, signal_connect_verbose);
  ualarm(10, 0);
 
  FO_ASSERT_PTR_NULL(fo_scheduler_next());
  FO_ASSERT_FALSE(valid);
}
 
void test_scheduler_next_version()
{
  write_con("VERSION\n");
 
  signal(SIGALRM, signal_connect_version);
  ualarm(10, 0);
 
  FO_ASSERT_PTR_NULL(fo_scheduler_next());
  FO_ASSERT_FALSE(valid);
}
 
void test_scheduler_next_oth()
{
  char* ret;
 
  write_con(NC_TEST);
 
  FO_ASSERT_PTR_NOT_NULL((ret = fo_scheduler_next()));
  FO_ASSERT_STRING_EQUAL(ret, NC_TEST);
  FO_ASSERT_TRUE(valid);
}
 
void test_scheduler_current()
{
  FO_ASSERT_STRING_EQUAL(fo_scheduler_current(), NC_TEST);
 
  write_con("CLOSE\n");
 
  FO_ASSERT_PTR_NULL(fo_scheduler_next());
  FO_ASSERT_PTR_NULL(fo_scheduler_current());
}
 
void test_scheduler_disconnect()
{
  sscheduler = 1;
 
  fo_scheduler_disconnect(2);
  FO_ASSERT_STRING_EQUAL(fgets(tbuffer, sizeof(tbuffer), read_from), "BYE 2\n");
  FO_ASSERT_FALSE(valid);
  FO_ASSERT_FALSE(sscheduler);
}
 
void test_scheduler_heart()
{
  FO_ASSERT_EQUAL(items_processed, 0);
  fo_scheduler_heart(1);
  FO_ASSERT_EQUAL(items_processed, 1);
  fo_scheduler_heart(10);
  FO_ASSERT_EQUAL(items_processed, 11);
 
  signal(SIGALRM, fo_heartbeat);
  ualarm(10, 0);
  usleep(20);
 
  FO_ASSERT_STRING_EQUAL(
    fgets(tbuffer, sizeof(tbuffer), read_from),
    "HEART: 11\n");
}
 
/* ************************************************************************** */
/* *** cunit test info ****************************************************** */
/* ************************************************************************** */
 
CU_TestInfo fossscheduler_testcases[] =
  {
    {"fossscheduler set up", set_up},
    {"fossscheduler no connect", test_scheduler_no_connect},
    {"fossscheduler connect", test_scheduler_connect},
    {"fossscheduler next close", test_scheduler_next_close},
    {"fossscheduler next end", test_scheduler_next_end},
    {"fossscheduler next verbose", test_scheduler_next_verbose},
    {"fossscheduler next version", test_scheduler_next_version},
    {"fossscheduler next oth", test_scheduler_next_oth},
    {"fossscheduler current", test_scheduler_current},
    {"fossscheduler disconnect", test_scheduler_disconnect},
    {"fossscheduler heat", test_scheduler_heart},
    {"fossscheduler tear down", tear_down},
    CU_TEST_INFO_NULL
  };