TEST_F(TestProjector, TestObjCache) {
  // schema for input fields
  auto field0 = field("f0", int32());
  auto field1 = field("f2", int32());
  auto field2 = field("f0", arrow::float64());
  auto field3 = field("f2", arrow::float64());
  auto field4 = field("f0", arrow::utf8());

  auto schema1 = arrow::schema({field0, field1});
  auto schema2 = arrow::schema({field2, field3});
  auto schema3 = arrow::schema({field4});

  // output fields
  auto field_sum = field("add", int32());
  auto field_sub = field("subtract", int32());
  auto field_mul = field("multiply", int32());
  auto field_div = field("divide", int32());
  auto field_eq = field("equal", arrow::boolean());
  auto field_lt = field("less_than", arrow::boolean());
  auto field_logb = arrow::field("logb", arrow::float64());
  auto field_power = arrow::field("power", arrow::float64());
  auto res_float8 = field("res_float8", arrow::float64());
  auto res_int4 = field("castBIGINT", arrow::int32());

  // Build expressions for schema1
  auto sum_expr = TreeExprBuilder::MakeExpression("add", {field0, field1}, field_sum);
  auto sub_expr =
      TreeExprBuilder::MakeExpression("subtract", {field0, field1}, field_sub);
  auto mul_expr =
      TreeExprBuilder::MakeExpression("multiply", {field0, field1}, field_mul);
  auto div_expr = TreeExprBuilder::MakeExpression("divide", {field0, field1}, field_div);
  auto eq_expr = TreeExprBuilder::MakeExpression("equal", {field0, field1}, field_eq);
  auto lt_expr = TreeExprBuilder::MakeExpression("less_than", {field0, field1}, field_lt);

  // Build expressions for schema2
  auto logb_expr = TreeExprBuilder::MakeExpression("log", {field2, field3}, field_logb);
  auto power_expr =
      TreeExprBuilder::MakeExpression("power", {field2, field3}, field_power);

  // Build expressions for schema3
  auto cast_expr_float8 =
      TreeExprBuilder::MakeExpression("castFLOAT8", {field4}, res_float8);
  auto cast_expr_int8 = TreeExprBuilder::MakeExpression("castINT", {field4}, res_int4);

  auto configuration = TestConfiguration();

  // Uses field0, field1 and schema1
  ExpressionVector exprVec1 = {sum_expr};
  ExpressionVector exprVec2 = {sub_expr};
  ExpressionVector exprVec3 = {mul_expr};
  ExpressionVector exprVec4 = {div_expr};
  ExpressionVector exprVec5 = {eq_expr};
  ExpressionVector exprVec6 = {lt_expr};

  // Uses field2, field3 and schema2
  ExpressionVector exprVec7 = {logb_expr};
  ExpressionVector exprVec8 = {power_expr};

  // Uses field4 and schema3
  ExpressionVector exprVec9 = {cast_expr_float8};
  ExpressionVector exprVec10 = {cast_expr_int8};

  unsigned int microsecond = 1000000;
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 1st projector
  std::shared_ptr<Projector> projector1;
  auto status = Projector::Make(schema1, exprVec1, configuration, &projector1);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // delete projector1 // -> gives the following error:
  // error: type ‘class std::shared_ptr<gandiva::Projector>’ argument given to ‘delete’, expected pointer

  //delete projector1.get(); // -> gives the following error:
  // double free() call. Process finished with exit code 139 (interrupted by signal 11: SIGSEGV)

  // If this line is looged, thant the shared_ptr will be the only ptr holding the projector
  // so reseting it will explicit delete it.
  if(projector1.unique()){
    ARROW_LOG(INFO) << "ONLY PTR TO THE PROJECTOR INSTANCE.";
  }
  // safer way to delete the projector as the deleter param of shared_ptr is the delete func by default.
  // ref: https://en.cppreference.com/w/cpp/memory/shared_ptr/reset
  projector1.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 2nd projector
  std::shared_ptr<Projector> projector2;
  status = Projector::Make(schema1, exprVec2, configuration, &projector2);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector2.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 3rd projector
  std::shared_ptr<Projector> projector3;
  status = Projector::Make(schema1, exprVec3, configuration, &projector3);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector3.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 4th projector
  std::shared_ptr<Projector> projector4;
  status = Projector::Make(schema1, exprVec4, configuration, &projector4);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector4.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 5th projector
  std::shared_ptr<Projector> projector5;
  status = Projector::Make(schema1, exprVec5, configuration, &projector5);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector5.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 6th projector
  std::shared_ptr<Projector> projector6;
  status = Projector::Make(schema1, exprVec6, configuration, &projector6);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector6.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 7th projector
  std::shared_ptr<Projector> projector7;
  status = Projector::Make(schema2, exprVec7, configuration, &projector7);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector7.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 8th projector
  std::shared_ptr<Projector> projector8;
  status = Projector::Make(schema2, exprVec8, configuration, &projector8);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector8.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 9th projector
  std::shared_ptr<Projector> projector9;
  status = Projector::Make(schema3, exprVec9, configuration, &projector9);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector9.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second

  // 10th projector
  std::shared_ptr<Projector> projector10;
  status = Projector::Make(schema3, exprVec10, configuration, &projector10);
  ASSERT_OK(status);
  usleep(0.5 * microsecond);//sleeps for 0.5 second

  projector10.reset();

  usleep(0.5 * microsecond);//sleeps for 0.5 second
}