#include "y_test_h.h"

IMPLEMENTATION_FTEST() 

TEST(true__){
  PRINTF("another test again false\n");
  bool val_bool = false;
  ASSERT_TRUE(val_bool);
}

TEST(test)
{
  PRINTF("test test\n");
  bool val_bool = true;
  ASSERT_FALSE(val_bool);

}


TEST(float_equal){
  PRINTF("another test float\n");
  ASSERT_TRUE(true);
  float a = 1.00001f;
  float b = 1.00001f;
  ASSERT_EQ_TYPE_FLOAT(a,b);
  b=1.0000101f;
  ASSERT_EQ_TYPE_FLOAT(a,b);
  ASSERT_EQ_TYPE_FLOAT(1.0000102f,b);
}
TEST(double_equal){
  PRINTF("another test double\n");
  ASSERT_TRUE(true);
  double a = 1.00000001;
  double b = 1.00000001;
  ASSERT_EQ_TYPE_DOUBLE(a,b);
  b=1.00000001000000001;
  ASSERT_EQ_TYPE_DOUBLE(a,b);
  ASSERT_EQ_TYPE_DOUBLE(1.0000000100000002,b);
}

TEST(unsigned){
  unsigned char c = 'a';

  LOG("another test, a = %c\n",c);
  EXPECT_EQ('a',c);
  ASSERT_FALSE(true);
  ASSERT_TRUE(true);
  ASSERT_TRUE(true);
}


TEST(){
//  sleep(3);
  int a = 5;
  long b = 5;
  ASSERT_EQ(a,b);
  a=4;
  ASSERT_EQ(a,b);

}

TEST(expect){
//  sleep(2);
  int a = 5;
  int b = 6;
  EXPECT_EQ(a,b);
  // SKIP();
  SKIP("%s\n","on skip eq string");
  EXPECT_EQ_TYPE_STRING("hello","hello");
  float f1 = 1.00019999, f2=1.00019999;
  EXPECT_EQ_TYPE_FLOAT(f1,f2);

}


TEST(){
  PRINTF("no test, only print\n");
}

TEST(){
  PRINTF("no test, only print\n");
}

TEST(){
  PRINTF("no test, only print\n");
}


TEST(lessThan){
  long int a=1,b=2;
  EXPECT_LT(a,b);
  EXPECT_LT(b,a);

  double da=0.1,db=0.2;
  EXPECT_LT_TYPE_DOUBLE(da,db);
  EXPECT_LT_TYPE_DOUBLE(db,da);
}

IMPLEMENTATION_FMOCK()

MOCK_FUNC(int, f_mock, (), ())






EXPECT_MOCK_CALL(int,f_mock, (),false, 2)  {
  EXPECT_EQ_IN_MOCKF(21,21,f_mock);
  EXPECT_EQ(1,3);
  EXPECT_EQ(4,4);
  EXPECT_EQ_IN_MOCKF(23,24,f_mock); return 12;}
EXPECT_MOCK_CALL(int,f_mock, (),1, 1)  { EXPECT_EQ_IN_MOCKF(23,21,f_mock);return 10;}

EXPECT_MOCK_CALL(int,f_mock, (),1==2||2<1, 1)  {return 18;}
EXPECT_MOCK_CALL(int,f_mock, (),1, ININITY_REPS)  {return -18;}


TEST(mockf1){
  INIT_CALLER_MOCK(f_mock);

  for(int i = 0; i<8; ++i){

   LOG("call f_mock:%d: ret:%d\n",i,f_mock());
   // int val=f_mock();
    //PRINTF("call f_mock:%d: ret:%d\n",i,val);
  }

}


// //

MOCK_FUNC(int, f2_mock,(int a,int b),(a,b))

STR_PRINT_CUR_VAR(f2_mock, (int a,int b),(a,b)){
  char *ret=malloc(150);
  //char ret[150];
  sprintf(ret,"(int)a: %d, (int)b: %d",a,b);
  return ret;
}


EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), (a<b), 3){
  return a+b;
}

EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), ((a<b)&&(b<100)), 1){
  return a*b;
}

WILL_MOCK_CALL(int, f2_mock, (int a,int b), (a!=b), 6){
  return a/b;
}
EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), (a==b), 1){
  return a/b;
}


// //

MOCK_FUNC(int, f3_mock,(int a,int b),(a,b))

EXPECT_MOCK_CALL(int, f3_mock, (int a,int b), (a<b), 2){
  return a+b;
}

EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), ((a<b)&&(b<100)), 1){
  return a*b;
}

WILL_MOCK_CALL(int, f2_mock, (int a,int b), (a!=b), 6){
  return a/b;
}
EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), (a==b), 1){
  return a/b;
}


// //

EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), (1), ININITY_REPS){
  return a*b;
}

TEST(f2mock_test){
  INIT_CALLER_MOCK(f2_mock);
  //LOG("--------------------------- > call f2_mock:%d: %d\n",0,f2_mock(1,4));


  for(int i=0; i<8; ++i){

    if(i<2) {
      //int val = f2_mock(i,4);
      //LOG("call f2_mock:%d: %d\n",i,val);
      LOG("call f2_mock:%d: %d\n",i,f2_mock(i,4));

    }
    else if(i<4) LOG("call:%d: %d\n",i,f2_mock(i,3));
    else LOG("call:%d:%d\n",i,f2_mock(i,i*i));
  }

}


int main(int argc, char **argv){
  //run_all_tests();
  //run_all_tests_parallel(4);

  run_all_tests_args(argc, argv);

  return 0;
}