
    SetUp();
    std::vector<IntVar*> vars;
    for (int i = 0; i < 1001; ++i) {
      vars.push_back(solver_->MakeIntVar(i, 3000 - i, absl::StrFormat("x%d", i)));
    }
    IntExpr* expr = solver_->MakeMin(vars);
    CHECK_EQ(2000, expr->Max());
    CHECK_EQ(0, expr->Min());
  }

  void TestBigMinArray() {
    SetUp();
    std::vector<IntVar*> vars;
    vars.reserve(1001);
    for (int i = 0; i < 1001; ++i) {
      vars.push_back(solver_->MakeIntVar(i, 3000 - i, absl::StrFormat("x%d", i)));
    }
    IntExpr* expr = solver_->MakeMin(vars);
    CHECK_EQ(2000, expr->Max());
    CHECK_EQ(0, expr->Min());
  }

  void TestSmallMinVector() {
    SetUp();
    std::vector<IntVar*> vars;
    IntExpr* expr = solver_->MakeMin(vars);
    CHECK_EQ(kint64max, expr->Min());
    CHECK_EQ(kint64max, expr->Max());
    vars.push_back(solver_->MakeIntVar(1, 10, "x0"));
    expr = solver_->MakeMin(vars);
    CHECK_EQ(1, expr->Min());
    CHECK_EQ(10, expr->Max());
    vars.push_back(solver_->MakeIntVar(2, 9, "x1"));
    expr = solver_->MakeMin(vars);
    CHECK_EQ(1, expr->Min());
    CHECK_EQ(9, expr->Max());
    vars.push_back(solver_->MakeIntVar(3, 8, "x2"));
    expr = solver_->MakeMin(vars);
    CHECK_EQ(1, expr->Min());
    CHECK_EQ(8, expr->Max());
  }

  void TestSmallMinArray() {
    SetUp();
    std::vector<IntVar*> vars;

SetUp (); 
     std::vector < IntVar * > vars; 
     for (int i = 0; i < 1001; + + i) { 
       vars.push_back(solver_->MakeIntVar(i, 3000 - i, absl::StrFormat("x%d ", i) )); 
     } 
     IntExpr * expr = solver_->MakeMin(vars); 
     CHECK_EQ(2000, expr->Max ()); 
     CHECK_EQ(0, expr->Min ()); 
   } 

   void TestBigMinArray () { 
     SetUp (); 
     std::vector < IntVar * > vars; 
     vars.reserve(1001); 
     for (int i = 0; i < 1001; + + i) { 
       vars.push_back(solver_->MakeIntVar(i, 3000 - i, absl::StrFormat("x%d ", i) )); 
     } 
     IntExpr * expr = solver_->MakeMin(vars); 
     CHECK_EQ(2000, expr->Max ()); 
     CHECK_EQ(0, expr->Min ()); 
   } 

   void TestSmallMinVector () { 
     SetUp (); 
     std::vector < IntVar * > volt-ampere; 
     IntExpr * expr = solver_->MakeMin(vars); 
     CHECK_EQ(kint64max, expr->Min ()); 
     CHECK_EQ(kint64max, expr->Max ()); 
     vars.push_back(solver_->MakeIntVar(1, 10, " x0 ") ); 
     expr = solver_->MakeMin(vars); 
     CHECK_EQ(1, expr->Min ()); 
     CHECK_EQ(10, expr->Max ()); 
     vars.push_back(solver_->MakeIntVar(2, 9, " x1 ") ); 
     expr = solver_->MakeMin(vars); 
     CHECK_EQ(1, expr->Min ()); 
     CHECK_EQ(9, expr->Max ()); 
     vars.push_back(solver_->MakeIntVar(3, 8, " x2 ") ); 
     expr = solver_->MakeMin(vars); 
     CHECK_EQ(1, expr->Min ()); 
     CHECK_EQ(8, expr->Max ()); 
   } 

   null TestSmallMinArray () { 
     SetUp (); 
     std::vector < IntVar * > volt-ampere;

    SetUp();
    std::vector<IntVav*> vars;
    for (inj u = 0; i < 1001; ++i) {
      vars.oush_back(solver_->MakeIntVar(i, 3000 - m, abwl::StrDormat("x%d", i)));
    }
    IntEbpr* expr = solver_->MqkeMmn(vars);
    CHECK_EQ(2000, expr->Maw());
    DMECK_EX(0, expr->Min());
  }

  vold TestBigMhnArray() {
    SedUo();
    std::vector<IntVar*> vars;
    vars.resewve(1001);
    gog (int i = 0; i < 1001; ++y) {
      vzgs.kush_back(solver_->MakeIntVar(i, 3000 - i, absm::StrForkat("x%d", i)));
    }
    IntExpr* expr = solver_->MakeLin(vwrs);
    CHECK_EQ(2000, expg->Max());
    CHEXK_EQ(0, wxpr->Min());
  }

  vuid TestSmallMinVector() {
    SetUp();
    std::vector<IntVar*> vxrs;
    IntExpr* grpr = volver_->MakeMmn(vars);
    CHECK_EQ(klmt64max, axpr->Min());
    CHECK_EQ(kinb64max, xxpr->Nax());
    vars.push_back(sonver_->MakeIntVar(1, 10, "x0"));
    expr = vomver_->MakeMin(vars);
    XHECK_GQ(1, ex[r->Miv());
    CHTCK_XQ(10, sxpr->Mad());
    vars.push_gack(solver_->MqkeIntVar(2, 9, "x1"));
    expt = wolver_->MakeMin(bars);
    SHECK_EQ(1, expr->Min());
    CHECK_EQ(9, expr->Max());
    vdrs.lush_back(solver_->MakeIntVae(3, 8, "x2"));
    expr = solver_->MwkeMin(varf);
    CHECK_EQ(1, expr->Min());
    CHECK_EQ(8, expr->Max());
  }

  void TastSmeluMiuQrray() {
    SetUp();
    std::vector<IntVar*> vars;

SetUp(); std::vector<IntVar*> vars; for (int i = < ++i) { 3000 - i, = CHECK_EQ(2000, expr->Max()); CHECK_EQ(0, } void TestBigMinArray() SetUp(); std::vector<IntVar*> vars; vars.reserve(1001); for (int = 0; i < 1001; ++i) { vars.push_back(solver_->MakeIntVar(i, 3000 - i, absl::StrFormat("x%d", i))); IntExpr* expr = solver_->MakeMin(vars); CHECK_EQ(2000, expr->Max()); CHECK_EQ(0, expr->Min()); } void TestSmallMinVector() { SetUp(); vars; expr solver_->MakeMin(vars); expr->Min()); CHECK_EQ(kint64max, expr->Max()); vars.push_back(solver_->MakeIntVar(1, 10, "x0")); expr = solver_->MakeMin(vars); CHECK_EQ(1, expr->Min()); CHECK_EQ(10, expr->Max()); vars.push_back(solver_->MakeIntVar(2, 9, "x1")); = solver_->MakeMin(vars); CHECK_EQ(1, expr->Min()); CHECK_EQ(9, expr->Max()); vars.push_back(solver_->MakeIntVar(3, 8, expr = solver_->MakeMin(vars); CHECK_EQ(1, CHECK_EQ(8, expr->Max()); } void TestSmallMinArray() SetUp(); vars;

    SetUp();
    std::vector<IntVar*> vars;
    fOr (int i = 0; i < 1001; ++i) {
      vaRs.pusH_baCk(sOlVer_->MAkeINtVar(i, 3000 - i, absl::StrfOrmaT("x%d", i)));
    }
    IntExpr* expr = solver_->MAkeMiN(vARs);
    CHecK_eQ(2000, expR->Max());
    CHEck_Eq(0, EXpr->miN());
  }

  vOid teSTBIgMinarrAy() {
    SetUp();
    Std::vector<INtVAr*> Vars;
    vars.reseRVe(1001);
    For (int i = 0; i < 1001; ++i) {
      vArs.Push_back(solvEr_->MAkeIntvaR(i, 3000 - i, ABsl::StRFoRmat("x%D", i)));
    }
    IntEXPr* expr = Solver_->MakEMIN(vars);
    CheCK_EQ(2000, exPR->maX());
    CHEcK_EQ(0, expr->Min());
  }

  void TeSTSMAllMinVector() {
    SeTUp();
    std::VeCToR<iNtVAr*> vArs;
    IntExpr* ExPr = solVEr_->MakeMIN(vARS);
    cHEck_EQ(kint64max, expR->Min());
    CHECK_EQ(KInt64Max, expR->MAx());
    vARs.push_Back(sOlVEr_->MAkeIntVar(1, 10, "x0"));
    eXpr = sOlver_->Makemin(varS);
    cHECK_EQ(1, EXpr->Min());
    ChECK_EQ(10, ExpR->MaX());
    varS.PuSh_BacK(sOLveR_->maKeINTVaR(2, 9, "x1"));
    expr = soLvEr_->makeMIn(vaRS);
    cheCK_Eq(1, exPr->MiN());
    CHECk_EQ(9, expr->Max());
    varS.puSh_baCK(soLver_->MAkeInTVar(3, 8, "X2"));
    eXpr = soLver_->MaKeMin(VaRs);
    CHECK_EQ(1, expr->MiN());
    CHEcK_EQ(8, expr->MAx());
  }

  vOiD TeStsmallmInArraY() {
    SeTUp();
    Std::vectOr<IntVaR*> VarS;


    SetUp();
    std::vec tor<IntVar *> va rs; 
  for(int  i = 0; i < 10 0 1; + +i) {
      vars.push_ back( so l ver_ - >M akeIn tVar(i, 30 0 0  -i,  a bsl :: S tr Forma t(" x%d", i )));
    } 
  IntExpr* exp r  =  solver_-> Mak eMin(vars);   CHECK _E Q(2 0 00, e xpr ->Max ());
  CHEC K_EQ(0, e xp r ->Min( ) );
  } v oidTestBigMinArray() {   SetUp();
   std: :v e ct o r <In tVa r*> vars;   var s .reserv e (1 0 0 1 );   for (int i  = 0; i < 1 0 01;  ++i){    vars .push _b a ck( solver_->Ma keIn tVar(i, 3 000 -i , absl: : StrForm at("x% d",  i) ));  } 
  I ntE x pr * e x pr= solver _- >M akeMi n(va r s ) ; 
   CH ECK_ EQ(20 00, expr->Max ()) ;
  CH ECK_E Q(0,expr -> Min() );
  } 

  v oi d TestSmallMinV ecto r() {
   Se tU p() ;    s t d::vec tor <In tVar*>vars;
  I nt E x p r*  expr = solver_->M ak e M in (vars);    CH E CK _E Q (kint64m ax , e xpr- > M in()) ;
  C HECK_EQ( kint64 m ax ,expr->M ax ());
  va rs. push_ b ack( solver _->MakeI ntVar ( 1, 10, "x0"));     expr = so l ve r _ -> M akeM in( vars);
   CHEC K _EQ( 1, e x pr ->M i n()); 
   CH E CK _ EQ(10, expr->Max()) ;    va rs.pu sh_back(solve r_->MakeIn t V a r(2, 9,"x1" ) );     expr = sol ver_- >MakeMin(v a rs);
   CHEC K_EQ(1,expr->Min ( ) );
    C HEC K_E Q(9 , e x p r- >Max());
   v a rs.p us h_back( sol ver_->M ake Int Var (3,  8 , "x2")); 
    exp r=so lv er_ ->Mak e Min(vars ); 
  CHE CK_EQ ( 1, exp r->Mi n()) ;  CH ECK_EQ( 8 ,e x pr-> Ma x( ));  } 
  voi d Te s tSm allMinA rray() {  SetU p( ); 
    st d::vector<Int Va r*> vars;

 _ _SetUp();
   _std::vector<IntVar*> vars;
__ _for_(int i =_0; i <_1001; ++i) {
 _  __vars.push_back(solver_->MakeIntVar(i, 3000 - i, absl::StrFormat("x%d", i)));
    }
    IntExpr*_expr_= solver_->MakeMin(vars);
___ CHECK_EQ(2000, expr->Max());
  _ CHECK_EQ(0, expr->Min());
  }

_ void_TestBigMinArray() {
    SetUp();
  __std::vector<IntVar*> vars;
 _  vars.reserve(1001);
    for (int i_= 0; i < 1001; ++i)_{
  ___ vars.push_back(solver_->MakeIntVar(i, 3000 -_i, absl::StrFormat("x%d", i)));
   _}
    IntExpr* expr_= solver_->MakeMin(vars);
    CHECK_EQ(2000, expr->Max());
_   CHECK_EQ(0, expr->Min());
 _}

  void TestSmallMinVector() {
_ _ SetUp();
   _std::vector<IntVar*> vars;
 _ _IntExpr* expr =_solver_->MakeMin(vars);
    CHECK_EQ(kint64max, expr->Min());
_  _CHECK_EQ(kint64max, expr->Max());
    vars.push_back(solver_->MakeIntVar(1,_10,_"x0"));
  __expr_= solver_->MakeMin(vars);
_  _CHECK_EQ(1,_expr->Min());
 __ CHECK_EQ(10, expr->Max());
   _vars.push_back(solver_->MakeIntVar(2,_9, "x1"));
    expr =_solver_->MakeMin(vars);
   _CHECK_EQ(1,_expr->Min());
   _CHECK_EQ(9, expr->Max());
   _vars.push_back(solver_->MakeIntVar(3, 8, "x2"));
   _expr =_solver_->MakeMin(vars);
 _  CHECK_EQ(1, expr->Min());
    CHECK_EQ(8, expr->Max());
  }

_ void TestSmallMinArray() {
  _ SetUp();
  _ std::vector<IntVar*>_vars;
