diff --git a/src/tests/src/solver/optim-model-filler/test_componentFiller.cpp b/src/tests/src/solver/optim-model-filler/test_componentFiller.cpp
index 58e2745e62..5f8a8a8484 100644
--- a/src/tests/src/solver/optim-model-filler/test_componentFiller.cpp
+++ b/src/tests/src/solver/optim-model-filler/test_componentFiller.cpp
@@ -75,11 +75,12 @@ struct LinearProblemBuildingFixture
                                     Node* lb,
                                     Node* ub,
                                     const vector<ConstraintData>& constraintsData,
-                                    Node* objective = nullptr)
+                                    Node* objective = nullptr,
+                                    bool time_dependent = false)
     {
         createModel(modelId,
                     parameterIds,
-                    {{varId, ValueType::FLOAT, lb, ub, false, false}},
+                    {{varId, ValueType::FLOAT, lb, ub, time_dependent, false}},
                     constraintsData,
                     objective);
     }
@@ -117,7 +118,13 @@ struct LinearProblemBuildingFixture
         return nodes.create<NegationNode>(node);
     }
 
-    void buildLinearProblem();
+    void buildLinearProblem(FillContext& time_scenario_ctx);
+
+    void buildLinearProblem()
+    {
+        FillContext time_scenario_ctx = {0, 0};
+        buildLinearProblem(time_scenario_ctx);
+    }
 };
 
 void LinearProblemBuildingFixture::createModel(string modelId,
@@ -180,7 +187,7 @@ void LinearProblemBuildingFixture::createComponent(const string& modelId,
     components.push_back(move(component));
 }
 
-void LinearProblemBuildingFixture::buildLinearProblem()
+void LinearProblemBuildingFixture::buildLinearProblem(FillContext& time_scenario_ctx)
 {
     vector<unique_ptr<ComponentFiller>> fillers;
     vector<LinearProblemFiller*> fillers_ptr;
@@ -196,8 +203,8 @@ void LinearProblemBuildingFixture::buildLinearProblem()
     pb = make_unique<Antares::Solver::Modeler::OrtoolsImpl::OrtoolsLinearProblem>(false, "sirius");
     LinearProblemBuilder linear_problem_builder(fillers_ptr);
     LinearProblemData dummy_data;
-    FillContext dummy_time_scenario_ctx = {0, 0};
-    linear_problem_builder.build(*pb.get(), dummy_data, dummy_time_scenario_ctx);
+
+    linear_problem_builder.build(*pb, dummy_data, time_scenario_ctx);
 }
 
 BOOST_FIXTURE_TEST_SUITE(_ComponentFiller_addVariables_, LinearProblemBuildingFixture)
@@ -218,6 +225,34 @@ BOOST_AUTO_TEST_CASE(var_with_literal_bounds_to_filler__problem_contains_one_var
     BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(var), 0);
 }
 
+BOOST_AUTO_TEST_CASE(ten_timesteps_var_with_literal_bounds_to_filler__problem_contains_ten_vars)
+{
+    createModelWithOneFloatVar("some_model",
+                               {},
+                               "var1",
+                               literal(-5),
+                               literal(10),
+                               {},
+                               nullptr,
+                               true);
+    createComponent("some_model", "some_component");
+    constexpr unsigned int last_time_step = 9;
+    FillContext ctx{0, last_time_step};
+    buildLinearProblem(ctx);
+    const auto nb_var = ctx.getNumberOfTimestep(); // = 10
+    BOOST_CHECK_EQUAL(pb->variableCount(), nb_var);
+    BOOST_CHECK_EQUAL(pb->constraintCount(), 0);
+    for (unsigned int i = 0; i < nb_var; i++)
+    {
+        auto* var = pb->getVariable("some_component.var1_" + to_string(i));
+        BOOST_REQUIRE(var);
+        BOOST_CHECK_EQUAL(var->getLb(), -5);
+        BOOST_CHECK_EQUAL(var->getUb(), 10);
+        BOOST_CHECK(!var->isInteger());
+        BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(var), 0);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(var_with_wrong_parameter_lb__exception_is_raised)
 {
     createModel("my-model",
@@ -263,6 +298,35 @@ BOOST_AUTO_TEST_CASE(two_variables_given_to_different_fillers__LP_contains_the_t
     BOOST_CHECK_EQUAL(var2->getUb(), 2.);
 }
 
+BOOST_AUTO_TEST_CASE(
+  two_times_10_variables_given_to_different_fillers__LP_contains_the_two_variables)
+{
+    createModelWithOneFloatVar("m1", {}, "var1", literal(-1), literal(6), {}, nullptr, true);
+    createModelWithOneFloatVar("m2", {}, "var2", literal(-3), literal(2), {}, nullptr, true);
+    createComponent("m1", "component_1");
+    createComponent("m2", "component_2");
+    constexpr unsigned int last_time_step = 9;
+    FillContext ctx{0, last_time_step};
+    buildLinearProblem(ctx);
+    const auto nb_var = ctx.getNumberOfTimestep(); // = 10
+
+    BOOST_CHECK_EQUAL(pb->variableCount(), 2 * 10);
+    for (auto i = 0; i < nb_var; i++)
+    {
+        auto* var1 = pb->getVariable("component_1.var1_" + to_string(i));
+        BOOST_REQUIRE(var1);
+        BOOST_CHECK(!var1->isInteger());
+        BOOST_CHECK_EQUAL(var1->getLb(), -1.);
+        BOOST_CHECK_EQUAL(var1->getUb(), 6.);
+
+        auto* var2 = pb->getVariable("component_2.var2_" + to_string(i));
+        BOOST_REQUIRE(var2);
+        BOOST_CHECK(!var2->isInteger());
+        BOOST_CHECK_EQUAL(var2->getLb(), -3.);
+        BOOST_CHECK_EQUAL(var2->getUb(), 2.);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(var_whose_bounds_are_parameters_given_to_component__problem_contains_this_var)
 {
     createModel("model",
@@ -372,6 +436,39 @@ BOOST_AUTO_TEST_CASE(ct_one_var__pb_contains_the_ct)
     BOOST_CHECK_EQUAL(ct->getCoefficient(var), 1);
 }
 
+BOOST_AUTO_TEST_CASE(ct_with_ten_vars__pb_contains_ten_ct)
+{
+    // var1 <= 3
+    auto var_node = variable("var1", Antares::Solver::Visitors::TimeIndex::VARYING_IN_TIME_ONLY);
+    auto three = literal(3);
+    auto ct_node = nodes.create<LessThanOrEqualNode>(var_node, three);
+
+    createModel("model",
+                {},
+                {{"var1", ValueType::BOOL, literal(-5), literal(10), true, false}},
+                {{"ct1", ct_node}});
+    createComponent("model", "componentToto");
+    constexpr unsigned int last_time_step = 9;
+    FillContext ctx{0, last_time_step};
+    buildLinearProblem(ctx);
+    const auto nb_var = ctx.getNumberOfTimestep(); // = 10
+
+    BOOST_CHECK_EQUAL(pb->variableCount(), 10);
+    BOOST_CHECK_EQUAL(pb->constraintCount(), 10);
+
+    for (auto i = 0; i < nb_var; i++)
+    {
+        auto ct = pb->getConstraint("componentToto.ct1_" + to_string(i));
+        BOOST_REQUIRE(ct);
+        BOOST_CHECK_EQUAL(ct->getLb(), -pb->infinity());
+        BOOST_CHECK_EQUAL(ct->getUb(), 3);
+        auto var = pb->getVariable("componentToto.var1_" + to_string(i));
+        BOOST_REQUIRE(var);
+        BOOST_CHECK(var->isInteger());
+        BOOST_CHECK_EQUAL(ct->getCoefficient(var), 1);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(ct_one_var_with_coef__pb_contains_the_ct)
 {
     // 3 * var1 >= 5 * var1 + 5
@@ -512,6 +609,27 @@ BOOST_AUTO_TEST_CASE(one_var_with_objective)
     BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(pb->getVariable("componentA.x")), 1);
 }
 
+BOOST_AUTO_TEST_CASE(one_time_dependent_var_with_objective)
+{
+    auto objective = variable("x", Antares::Solver::Visitors::TimeIndex::VARYING_IN_TIME_ONLY);
+
+    createModelWithOneFloatVar("model", {}, "x", literal(-50), literal(-40), {}, objective, true);
+    createComponent("model", "componentA", {});
+
+    constexpr unsigned int last_time_step = 9;
+    FillContext ctx{0, last_time_step};
+    buildLinearProblem(ctx);
+    const auto nb_var = ctx.getNumberOfTimestep(); // = 10
+
+    BOOST_CHECK_EQUAL(pb->variableCount(), nb_var);
+    for (auto i = 0; i < nb_var; i++)
+    {
+        const auto var_name = "componentA.x_" + to_string(i);
+        BOOST_CHECK_NO_THROW(pb->getVariable(var_name));
+        BOOST_CHECK_EQUAL(pb->getObjectiveCoefficient(pb->getVariable(var_name)), 1);
+    }
+}
+
 BOOST_AUTO_TEST_CASE(two_vars_but_only_one_in_objective)
 {
     VariableData var1Data = {"v1", ValueType::FLOAT, literal(-50.), literal(300.), false, false};