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;
---------------------------------------------------------------------------------------------------------
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 :Double;
    result2 : boolean;
    A_Task :Generic_Task_Ptr;
    My_Tasks:Tasks_Set;
    Q: Integer := 1;
  
    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);
    result2 := compute_less(My_Tasks,To_Unbounded_String("CPU_A"));
    Put_line("result :" &result'img);
    Put_line("result2 :" &result2'img);
    
 end test_prog ;