with Text_IO;                           use Text_IO;
with Task_Set;                          use Task_Set;
with Ada.Exceptions;                    use Ada.Exceptions;
with initialize_framework;              use initialize_framework;
with Scheduler.Fixed_Priority;          use Scheduler.Fixed_Priority;
with Text_IO;                           use Text_IO;
with Ada.Strings.Unbounded;             use Ada.Strings.Unbounded;
with unbounded_strings;                 use unbounded_strings;
use unbounded_strings.strings_table_package;
use unbounded_strings.unbounded_string_list_package;
with Systems;                           use Systems;
with Call_Scheduling_Framework;         use Call_Scheduling_Framework;
with Multiprocessor_Services;           use Multiprocessor_Services;
with Multiprocessor_Services_Interface; use Multiprocessor_Services_Interface;
use Multiprocessor_Services_Interface.Scheduling_Result_Per_Processor_Package;
with Ada.Exceptions;                    use Ada.Exceptions;
with Scheduler_Interface;               use Scheduler_Interface;
with Processor_Set;                     use Processor_Set;
use Processor_Set.Generic_Processor_Set;
with Processors;                        use Processors;
with processor_interface;               use processor_interface;
with Core_Units;                        use Core_Units;
use Core_Units.Core_Units_Table_Package;
with Caches;                            use Caches;
use Caches.Caches_Table_Package;
with Parameters;                        use Parameters;
with Parameters.extended;               use Parameters.extended;
use Parameters.Framework_Parameters_Table_Package;
with Tasks;                             use Tasks;
use Tasks.Generic_Task_List_Package;
with Task_Groups;                       use Task_Groups;
with Task_Set;                          use Task_Set;
use Task_Set.Generic_Task_Set;
with Task_Group_Set;                    use Task_Group_Set;
use Task_Group_Set.Generic_Task_Group_Set;
with Resources;                         use Resources;
use Resources.Resource_Accesses;
with Resource_Set;                      use Resource_Set;
use Resource_Set.Generic_Resource_Set;
with Address_Space_Set;                 use Address_Space_Set;
use Address_Space_Set.Generic_Address_Space_Set;
with Offsets;                           use Offsets;
use Offsets.Offsets_Table_Package;
with Offsets.extended;                  use Offsets.extended;
with Buffer_Set;                        use Buffer_Set;
with Buffers;                           use Buffers;
use Buffers.Buffer_Roles_Package;
with Queueing_Systems;                  use Queueing_Systems;
with Message_Set;                       use Message_Set;
with Messages;                          use Messages;
with Network_Set;                       use Network_Set;
with Networks;                          use Networks;
with Task_Dependencies;                 use Task_Dependencies;
with Dependencies;                      use Dependencies;
with Objects;                           use Objects;
use Objects.Generic_Object_Set_Package;
with deployment_Set;                    use deployment_Set;
with Parameters;                        use Parameters;

with Feasibility_Test.processor_utilization;
use  Feasibility_Test.processor_utilization;
use Task_Set;
use Task_Set;
use Feasibility_Test.processor_utilization;
with Translate;                              use Translate;
with unbounded_strings;                      use unbounded_strings;
with Scheduler;                              use Scheduler;
with Scheduling_Analysis;                    use Scheduling_Analysis;
use Scheduling_Analysis.Double_Tasks_Parameters_Package;
with architecture_models;                    use architecture_models;
with Scheduler.Fixed_Priority;               use Scheduler.Fixed_Priority;
---------------------------package feasibility test
--generated-------------------------------------------
with Feasibility_Test.generated_R1; use Feasibility_Test.generated_R1;
with Feasibility_Test.generated_C2; use Feasibility_Test.generated_C2;

with Feasibility_Test.generated_R2; use Feasibility_Test.generated_R2;
-------------------------------------------------------------------------------
----------------------------
with Ada.Exceptions;                    use Ada.Exceptions;
with Resources;                         use Resources;
use Resources.Resource_Accesses;
with Time_Unit_Events;                  use Time_Unit_Events;
use Time_Unit_Events.Time_Unit_Package;
with natural_util;                      use natural_util;
with double_util;                       use double_util;
with integer_util;                      use integer_util;
with Ada.Numerics.Elementary_Functions; use Ada.Numerics.Elementary_Functions;
with Objects;                           use Objects;
with Objects.extended;                  use Objects.extended;
with Translate;                         use Translate;
with Multi_precision_integers;          use Multi_precision_integers;
with Multi_precision_integers_IO;       use Multi_precision_integers_IO;
with multi_int_util;                    use multi_int_util;
with Ada.Numerics.Aux;                  use Ada.Numerics.Aux;

-------------------------------------------------------------------------------
----------------------------
procedure test_prog is
   result, result3 : Double;
   result2         : Boolean;
   A_Task          : Generic_Task_Ptr;
   My_Tasks        : Tasks_Set;
   Q               : Double := 1.0;
   k               : Integer;
   W_i             : MY_ARRAY;
begin
   Set_Initialize;

   Add_Task
     (My_Tasks           => My_Tasks,
      Name               => To_Unbounded_String ("Task_F"),
      Cpu_Name           => To_Unbounded_String ("CPU_A"),
      Address_Space_Name => To_Unbounded_String ("ADDRESS_SPACE_A"),
      Task_Type          => Periodic_Type,
      Start_Time         => 0,
      Capacity           => 3,
      Period             => 7,
      Deadline           => 7,
      Jitter             => 0,
      Blocking_Time      => 0,
      Priority           => 6,
      Criticality        => 0,
      Policy             => Sched_Fifo);

   Add_Task
     (My_Tasks           => My_Tasks,
      Name               => To_Unbounded_String ("Task_E"),
      Cpu_Name           => To_Unbounded_String ("CPU_A"),
      Address_Space_Name => To_Unbounded_String ("ADDRESS_SPACE_A"),
      Task_Type          => Periodic_Type,
      Start_Time         => 0,
      Capacity           => 2,
      Period             => 12,
      Deadline           => 12,
      Jitter             => 0,
      Blocking_Time      => 0,
      Priority           => 5,
      Criticality        => 0,
      Policy             => Sched_Fifo);

   Add_Task
     (My_Tasks           => My_Tasks,
      Name               => To_Unbounded_String ("Task_D"),
      Cpu_Name           => To_Unbounded_String ("CPU_A"),
      Address_Space_Name => To_Unbounded_String ("ADDRESS_SPACE_A"),
      Task_Type          => Periodic_Type,
      Start_Time         => 0,
      Capacity           => 5,
      Period             => 20,
      Deadline           => 20,
      Jitter             => 0,
      Blocking_Time      => 0,
      Priority           => 1,
      Criticality        => 0,
      Policy             => Sched_Fifo);

   --A_Task := Search_Task (My_Tasks, To_Unbounded_String("Task_D"));
   sort (My_Tasks, Increasing_Priority'Access);
   A_Task := Search_Task (My_Tasks, To_Unbounded_String ("Task_D"));
   Put_Line ("Hello World");

   --result := Compute_Wiq_non_preemptive(My_Tasks, A_Task,Q);
   result  := compute_reponse_time_R1 (My_Tasks, A_Task);
   result2 := compute_less_C2 (My_Tasks, To_Unbounded_String ("CPU_A"));
   Put_Line ("result :" & result'Img);
   Put_Line ("result2 :" & result2'Img);
   compute_less_equal
     (My_Tasks,
      To_Unbounded_String ("CPU_A"),
      A_Task,
      W_i,
      k);
   result3 := max_r_i (My_Tasks, W_i, k, A_Task);
   Put_Line ("result3 :" & result3'Img);
end test_prog;