

TEST_F(FFFTestSuite, when_void_func_never_called_then_callcount_is_zero)
{
    ASSERT_EQ(voidfunc1_fake.call_count, 0u);
}

TEST_F(FFFTestSuite, when_void_func_called_once_then_callcount_is_one)
{
    voidfunc1(66);
    ASSERT_EQ(voidfunc1_fake.call_count, 1u);
}

TEST_F(FFFTestSuite, when_void_func_called_once_and_reset_then_callcount_is_zero)
{
    voidfunc1(66);
    RESET_FAKE(voidfunc1);
    ASSERT_EQ(voidfunc1_fake.call_count, 0u);
}

// Single Argument
TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_then_last_arg_captured)
{
    voidfunc1(77);
    ASSERT_EQ(voidfunc1_fake.arg0_val, 77);
}

TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_twice_then_last_arg_captured)
{
    voidfunc1(77);
    voidfunc1(12);
    ASSERT_EQ(voidfunc1_fake.arg0_val, 12);
}

TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_and_reset_then_captured_arg_is_zero)
{
    voidfunc1(11);
    RESET_FAKE(voidfunc1);
    ASSERT_EQ(voidfunc1_fake.arg0_val, 0);
}

// Two Arguments
TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_then_last_args_captured)
{
    voidfunc2('a', 'b');
    ASSERT_EQ(voidfunc2_fake.arg0_val, 'a');
    ASSERT_EQ(voidfunc2_fake.arg1_val, 'b');
}

TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_twice_then_last_args_captured)
{
    voidfunc2('a', 'b');
    voidfunc2('c', 'd');
    ASSERT_EQ(voidfunc2_fake.arg0_val, 'c');
    ASSERT_EQ(voidfunc2_fake.arg1_val, 'd');
}

TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_and_reset_then_captured_arg_is_zero)
{
    voidfunc2('e', 'f');
    RESET_FAKE(voidfunc2);
    ASSERT_EQ(voidfunc2_fake.arg0_val, 0);
    ASSERT_EQ(voidfunc2_fake.arg1_val, 0);
}

#ifndef __cplusplus
TEST_F(FFFTestSuite, when_fake_func_called_then_const_arguments_captured)
{
    char dst[80];
    strlcpy3(dst, __FUNCTION__, sizeof(__FUNCTION__));
}
#endif /* __cplusplus */

// Argument history
TEST_F(FFFTestSuite, when_fake_func_created_default_history_is_fifty_calls)
{
    ASSERT_EQ(FFF_ARG_HISTORY_LEN, (sizeof voidfunc2_fake.arg0_history) / (sizeof voidfunc2_fake.arg0_history[0]));
    ASSERT_EQ(FFF_ARG_HISTORY_LEN, (sizeof voidfunc2_fake.arg1_history) / (sizeof voidfunc2_fake.arg1_history[0]));
}

TEST_F(FFFTestSuite, when_fake_func_called_then_arguments_captured_in_history)
{
    voidfunc2('g', 'h');
    ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]);
    ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]);
}

TEST_F(FFFTestSuite, argument_history_is_reset_when_RESET_FAKE_called)
{
    //given
    voidfunc2('g', 'h');
    ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]);
    ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]);
    //when
    RESET_FAKE(voidfunc2);
    //then
    ASSERT_EQ('\0', voidfunc2_fake.arg0_history[0]);
    ASSERT_EQ('\0', voidfunc2_fake.arg1_history[0]);
}

TEST_F(FFFTestSuite, when_fake_func_called_max_times_then_no_argument_histories_dropped)
{
    unsigned int i;
    for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
    {
        voidfunc2('1' + i, '2' + i);
    }
    ASSERT_EQ(0u, voidfunc2_fake.arg_histories_dropped);
}

TEST_F(FFFTestSuite, when_fake_func_called_max_times_plus_one_then_one_argument_history_dropped)
{
    unsigned int i;
    for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
    {
        voidfunc2('1' + i, '2' + i);
    }
    voidfunc2('1', '2');
    ASSERT_EQ(1u, voidfunc2_fake.arg_histories_dropped);
    // or in other words..
    ASSERT_TRUE(voidfunc2_fake.call_count > voidfunc2_fake.arg_history_len);
}

// Return values
TEST_F(FFFTestSuite, value_func_will_return_zero_by_default)
{
    ASSERT_EQ(0l, longfunc0());
}

TEST_F(FFFTestSuite, value_func_will_return_value_given)
{
    longfunc0_fake.return_val = 99l;
    ASSERT_EQ(99l, longfunc0());
}

TEST_F(FFFTestSuite, value_func_will_return_zero_after_reset)
{
    longfunc0_fake.return_val = 99l;
    RESET_FAKE(longfunc0);
    ASSERT_EQ(0l, longfunc0());
}

TEST_F(FFFTestSuite, register_call_macro_registers_one_call)
{
    REGISTER_CALL(longfunc0);
    ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
}

TEST_F(FFFTestSuite, register_call_macro_registers_two_calls)
{
    REGISTER_CALL(longfunc0);
    REGISTER_CALL(voidfunc2);

    ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
    ASSERT_EQ(fff.call_history[1], (void *)voidfunc2);
}

TEST_F(FFFTestSuite, reset_call_history_resets_call_history)
{
    REGISTER_CALL(longfunc0);
    REGISTER_CALL(voidfunc1);
    FFF_RESET_HISTORY();
    REGISTER_CALL(voidfunc2);

    ASSERT_EQ(1u, fff.call_history_idx);
    ASSERT_EQ(fff.call_history[0], (void *)voidfunc2);
    ASSERT_EQ(fff.call_history[1], (void *)0);
}

TEST_F(FFFTestSuite, call_history_will_not_write_past_array_bounds)
{
    for (unsigned int i = 0; i < FFF_CALL_HISTORY_LEN + 1; i++)
    {
        REGISTER_CALL(longfunc0);
    }
    ASSERT_EQ(FFF_CALL_HISTORY_LEN, fff.call_history_idx);
}

TEST_F(FFFTestSuite, calling_fake_registers_one_call)
{
    longfunc0();
    ASSERT_EQ(fff.call_history_idx, 1u);
    ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
}

TEST_F(FFFTestSuite, return_value_sequences_not_exhausted)
{
    long myReturnVals[3] = { 3, 7, 9 };
    SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
    ASSERT_EQ(myReturnVals[0], longfunc0());
    ASSERT_EQ(myReturnVals[1], longfunc0());
    ASSERT_EQ(myReturnVals[2], longfunc0());
}


TEST_F(FFFTestSuite, return_value_sequences_exhausted)
{
    long myReturnVals[3] = { 3, 7, 9 };
    SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
    ASSERT_EQ(myReturnVals[0], longfunc0());
    ASSERT_EQ(myReturnVals[1], longfunc0());
    ASSERT_EQ(myReturnVals[2], longfunc0());
    ASSERT_EQ(myReturnVals[2], longfunc0());
    ASSERT_EQ(myReturnVals[2], longfunc0());
}

TEST_F(FFFTestSuite, return_value_sequences_reset)
{
    long myReturnVals[3] = { 3, 7, 9 };
    SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
    ASSERT_EQ(myReturnVals[0], longfunc0());
    ASSERT_EQ(myReturnVals[1], longfunc0());
    RESET_FAKE(longfunc0);
    ASSERT_EQ(0, longfunc0());
}

static int my_custom_fake_called = 0;
void my_custom_fake(char a, char b)
{
    my_custom_fake_called++;
}

TEST_F(FFFTestSuite, can_register_custom_fake)
{
    voidfunc2_fake.custom_fake = my_custom_fake;
    voidfunc2('a', 'b');
    ASSERT_EQ(1, my_custom_fake_called);
}

void voidfunc1outparam_custom_fake1(char *a)
{
  *a = 'x';
}

void voidfunc1outparam_custom_fake2(char *a)
{
  *a = 'y';
}

void voidfunc1outparam_custom_fake3(char *a)
{
  *a = 'z';
}

TEST_F(FFFTestSuite, custom_fake_sequence_not_exausthed)
{
  void (*custom_fakes[])(char *) = {voidfunc1outparam_custom_fake1,
                                    voidfunc1outparam_custom_fake2,
                                    voidfunc1outparam_custom_fake3};
  char a = 'a';

  SET_CUSTOM_FAKE_SEQ(voidfunc1outparam, custom_fakes, 3);

  voidfunc1outparam(&a);
  ASSERT_EQ('x', a);
  voidfunc1outparam(&a);
  ASSERT_EQ('y', a);
  voidfunc1outparam(&a);
  ASSERT_EQ('z', a);
}

TEST_F(FFFTestSuite, return_value_sequence_saved_in_history)
{
    long myReturnVals[3] = { 3, 7, 9 };
    SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
    longfunc0();
    longfunc0();
    longfunc0();
    ASSERT_EQ(myReturnVals[0], longfunc0_fake.return_val_history[0]);
    ASSERT_EQ(myReturnVals[1], longfunc0_fake.return_val_history[1]);
    ASSERT_EQ(myReturnVals[2], longfunc0_fake.return_val_history[2]);
}

TEST_F(FFFTestSuite, return_value_saved_in_history)
{
    long i;

    for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
    {
      longfunc0_fake.return_val = i + 1;
      longfunc0();
    }

    for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
    {
      ASSERT_EQ(longfunc0_fake.return_val_history[i], i + 1);
    }
}

long custom_longfunc1(void)
{
  return 42;
}

long custom_longfunc2(void)
{
  return 15;
}

long custom_longfunc3(void)
{
  return 7;
}

TEST_F(FFFTestSuite, custom_fake_seq_return_values_saved_in_history)
{
  long (*custom_fakes[])(void) = {custom_longfunc1,
                                  custom_longfunc2,
                                  custom_longfunc3};

  SET_CUSTOM_FAKE_SEQ(longfunc0, custom_fakes, 3);

  longfunc0();
  longfunc0();
  longfunc0();

  ASSERT_EQ(42, longfunc0_fake.return_val_history[0]);
  ASSERT_EQ(15, longfunc0_fake.return_val_history[1]);
  ASSERT_EQ(7, longfunc0_fake.return_val_history[2]);
}

TEST_F(FFFTestSuite, custom_fake_sequence_exhausted)
{
  void (*custom_fakes[])(char *) = {voidfunc1outparam_custom_fake1,
                                    voidfunc1outparam_custom_fake2,
                                    voidfunc1outparam_custom_fake3};
  char a = 'a';

  SET_CUSTOM_FAKE_SEQ(voidfunc1outparam, custom_fakes, 3);

  voidfunc1outparam(&a);
  ASSERT_EQ('x', a);
  voidfunc1outparam(&a);
  ASSERT_EQ('y', a);
  voidfunc1outparam(&a);
  ASSERT_EQ('z', a);
  a = 'a';
  voidfunc1outparam(&a);
  ASSERT_EQ('z', a);
  a = 'b';
  voidfunc1outparam(&a);
  ASSERT_EQ('z', a);
}
//DECLARE_FAKE_VALUE_FUNC0(long, longfunc0);
#define MEANING_OF_LIFE 42
long my_custom_value_fake(void)
{
    return MEANING_OF_LIFE;
}
TEST_F(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_return_value)
{
    longfunc0_fake.custom_fake = my_custom_value_fake;
    long retval = longfunc0();
    ASSERT_EQ(MEANING_OF_LIFE, retval);
}

int valuefunc3var_custom_fake1(const char *str, int a, va_list vl)
{
    int arg;
    while ((arg = va_arg(vl, int)) != 0)
        a += arg;
    return a;
}

int valuefunc3var_custom_fake2(const char *str, int a, va_list vl)
{
    int arg;
    while ((arg = va_arg(vl, int)) != 0)
        a -= arg;
    return a;
}

int valuefunc3var_custom_fake3(const char *str, int a, va_list vl)
{
    int arg;
    while ((arg = va_arg(vl, int)) != 0)
        a *= arg;
    return a;
}

TEST_F(FFFTestSuite, vararg_custom_fake_sequence_not_exhausted)
{
	int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1, 
                                                         valuefunc3var_custom_fake2,
	                                                     valuefunc3var_custom_fake3};
	SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
	int a = 1;
	ASSERT_EQ(valuefunc3var("a", a, 2, 3, 4, 0), 10);
	ASSERT_EQ(valuefunc3var("aa", a, 2, 3, 4, 2, 0), -10);
	ASSERT_EQ(valuefunc3var("aaa", a, 2, 3, 0), 6);
}

TEST_F(FFFTestSuite, vararg_custom_fake_seq_return_values_saved_in_history)
{
	int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
                                                         valuefunc3var_custom_fake2,
	                                                     valuefunc3var_custom_fake3};
	SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
	int a = 1;
	valuefunc3var("a", a, 2, 3, 4, 0);
	valuefunc3var("aa", a, 2, 3, 4, 2, 0);
	valuefunc3var("aaa", a, 2, 3, 0);
	ASSERT_EQ(10, valuefunc3var_fake.return_val_history[0]);
	ASSERT_EQ(-10, valuefunc3var_fake.return_val_history[1]);
	ASSERT_EQ(6, valuefunc3var_fake.return_val_history[2]);
}

TEST_F(FFFTestSuite, vararg_custom_fake_sequence_exhausted)
{
	int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
                                                         valuefunc3var_custom_fake2,
	                                                     valuefunc3var_custom_fake3};
	SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
	int a = 1;
	ASSERT_EQ(valuefunc3var("a", a, 2, 3, 4, 0), 10);
	ASSERT_EQ(valuefunc3var("aa", a, 2, 3, 4, 2, 0), -10);
	ASSERT_EQ(valuefunc3var("aaa", a, 2, 3, 0), 6);
	ASSERT_EQ(valuefunc3var("aaa", a, 4, 5, 1, 0), 20);
	ASSERT_EQ(valuefunc3var("aaa", a, 4, 0), 4);
}

TEST_F(FFFTestSuite, vararg_custom_fake_sequence_reset)
{
	int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
                                                         valuefunc3var_custom_fake2,
	                                                     valuefunc3var_custom_fake3};
	SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
	int a = 1;
	ASSERT_EQ(valuefunc3var("a", a, 2, 3, 4, 0), 10);
	ASSERT_EQ(valuefunc3var("aa", a, 2, 3, 4, 2, 0), -10);
	RESET_FAKE(valuefunc3var);
	ASSERT_EQ(0, valuefunc3var("b", 7, 4, 5));
	valuefunc3var_fake.return_val = 1;
	ASSERT_EQ(1, valuefunc3var("c", 5, 4, 4));
	valuefunc3var_fake.return_val = 2;
	ASSERT_EQ(2, valuefunc3var("d", 6, 3, 5));
}

TEST_F(FFFTestSuite, use_void_vararg_fake_with_different_number_of_arguments)
{
   voidfunc3var("0 parameters", 0);
   voidfunc3var("1 parameter",  1, 10);
   voidfunc3var("2 parameters", 2, 10, 20);
   voidfunc3var("3 parameters", 3, 10, 20, 30);

   ASSERT_EQ(voidfunc3var_fake.call_count, 4u);
   char msg[] = "3 parameters";
   ASSERT_EQ(strcmp(voidfunc3var_fake.arg0_val, msg), 0);
   ASSERT_EQ(3, voidfunc3var_fake.arg1_val);
}

TEST_F(FFFTestSuite, use_value_vararg_fake_with_different_number_of_arguments)
{
   valuefunc3var("0 parameters", 0);
   valuefunc3var("1 parameter",  1, 10);
   valuefunc3var("2 parameters", 2, 10, 20);
   valuefunc3var("3 parameters", 3, 10, 20, 30);

   ASSERT_EQ(valuefunc3var_fake.call_count, 4u);
   char msg[] = "3 parameters";
   ASSERT_EQ(strcmp(valuefunc3var_fake.arg0_val, msg), 0);
   ASSERT_EQ(3, valuefunc3var_fake.arg1_val);
}

TEST_F(FFFTestSuite, can_capture_upto_20_arguments_correctly)
{
    voidfunc20(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
    ASSERT_EQ(0, voidfunc20_fake.arg0_val);
    ASSERT_EQ(1, voidfunc20_fake.arg1_val);
    ASSERT_EQ(2, voidfunc20_fake.arg2_val);
    ASSERT_EQ(3, voidfunc20_fake.arg3_val);
    ASSERT_EQ(4, voidfunc20_fake.arg4_val);
    ASSERT_EQ(5, voidfunc20_fake.arg5_val);
    ASSERT_EQ(6, voidfunc20_fake.arg6_val);
    ASSERT_EQ(7, voidfunc20_fake.arg7_val);
    ASSERT_EQ(8, voidfunc20_fake.arg8_val);
    ASSERT_EQ(9, voidfunc20_fake.arg9_val);
    ASSERT_EQ(10, voidfunc20_fake.arg10_val);
    ASSERT_EQ(11, voidfunc20_fake.arg11_val);
    ASSERT_EQ(12, voidfunc20_fake.arg12_val);
    ASSERT_EQ(13, voidfunc20_fake.arg13_val);
    ASSERT_EQ(14, voidfunc20_fake.arg14_val);
    ASSERT_EQ(15, voidfunc20_fake.arg15_val);
    ASSERT_EQ(16, voidfunc20_fake.arg16_val);
    ASSERT_EQ(17, voidfunc20_fake.arg17_val);
    ASSERT_EQ(18, voidfunc20_fake.arg18_val);
    ASSERT_EQ(19, voidfunc20_fake.arg19_val);
}

TEST_F(FFFTestSuite, value_func_can_capture_upto_20_arguments_correctly)
{
    valuefunc20_fake.return_val = 42;

    int return_val = valuefunc20(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);

    ASSERT_EQ(42, return_val);
    ASSERT_EQ(0, valuefunc20_fake.arg0_val);
    ASSERT_EQ(1, valuefunc20_fake.arg1_val);
    ASSERT_EQ(2, valuefunc20_fake.arg2_val);
    ASSERT_EQ(3, valuefunc20_fake.arg3_val);
    ASSERT_EQ(4, valuefunc20_fake.arg4_val);
    ASSERT_EQ(5, valuefunc20_fake.arg5_val);
    ASSERT_EQ(6, valuefunc20_fake.arg6_val);
    ASSERT_EQ(7, valuefunc20_fake.arg7_val);
    ASSERT_EQ(8, valuefunc20_fake.arg8_val);
    ASSERT_EQ(9, valuefunc20_fake.arg9_val);
    ASSERT_EQ(10, valuefunc20_fake.arg10_val);
    ASSERT_EQ(11, valuefunc20_fake.arg11_val);
    ASSERT_EQ(12, valuefunc20_fake.arg12_val);
    ASSERT_EQ(13, valuefunc20_fake.arg13_val);
    ASSERT_EQ(14, valuefunc20_fake.arg14_val);
    ASSERT_EQ(15, valuefunc20_fake.arg15_val);
    ASSERT_EQ(16, valuefunc20_fake.arg16_val);
    ASSERT_EQ(17, valuefunc20_fake.arg17_val);
    ASSERT_EQ(18, valuefunc20_fake.arg18_val);
    ASSERT_EQ(19, valuefunc20_fake.arg19_val);
}