From 6a8edf6771541c323f2e8f4ce5446b1f86b61696 Mon Sep 17 00:00:00 2001 From: Marcus Rockwell Date: Sun, 12 May 2024 15:21:16 -0500 Subject: [PATCH] Allow for both gui and headless testing --- .../RUN_test/TESTING_CHECKPOINT_LOAD | 2256 +++++++++++++++++ trick_source/java/Makefile | 6 +- .../simcontrol/SimControlApplication.java | 15 +- .../test/java/trick/common/ActionInfo.java | 13 + .../java/trick/common/ApplicationTest.java | 60 +- .../test/java/trick/common/GUIController.java | 102 + .../simcontrol/SimControlApplicationTest.java | 466 +++- .../WaitForSimControlApplication.java | 138 + 8 files changed, 3027 insertions(+), 29 deletions(-) create mode 100644 test/SIM_gui_testing/RUN_test/TESTING_CHECKPOINT_LOAD create mode 100644 trick_source/java/src/test/java/trick/common/ActionInfo.java create mode 100644 trick_source/java/src/test/java/trick/common/GUIController.java create mode 100644 trick_source/java/src/test/java/trick/simcontrol/WaitForSimControlApplication.java diff --git a/test/SIM_gui_testing/RUN_test/TESTING_CHECKPOINT_LOAD b/test/SIM_gui_testing/RUN_test/TESTING_CHECKPOINT_LOAD new file mode 100644 index 00000000..dd3cf871 --- /dev/null +++ b/test/SIM_gui_testing/RUN_test/TESTING_CHECKPOINT_LOAD @@ -0,0 +1,2256 @@ +// Variable Declarations. +char trick_anon_local_0[25]; +char trick_anon_local_1[25]; +char trick_anon_local_2[25]; +char trick_anon_local_3[25]; +char trick_anon_local_4[25]; +Trick::RK4_Integrator trick_anon_local_5[1]; +er7_utils::SingleCycleIntegrationControls trick_anon_local_6[1]; +unsigned int trick_anon_local_7[4]; +double trick_anon_local_8[4]; +double trick_anon_local_9[4]; +double trick_anon_local_10[4]; +double* trick_anon_local_11[4]; +double* trick_anon_local_12[4]; +double* trick_anon_local_13[4]; +er7_utils::RK4FirstOrderODEIntegrator trick_anon_local_14[1]; +double trick_anon_local_15[4]; +double trick_anon_local_16[16]; +er7_utils::RK4SimpleSecondOrderODEIntegrator trick_anon_local_17[1]; +double trick_anon_local_18[2]; +double trick_anon_local_19[2]; +double trick_anon_local_20[8]; +double trick_anon_local_21[8]; +char* trick_anon_local_22[2]; +char trick_anon_local_23[31]; +char trick_anon_local_24[19]; +char trick_anon_local_25[25]; +Trick::JobData all_jobs[134]; +Trick::SimObject* trick_sys_sched_sim_objects[23]; +Trick::MessageSubscriber* trick_message_mpublisher_subscribers[5]; +std::string trick_jit_jit_file_to_libinfo_map_keys[1]; +Trick::JITLibInfo trick_jit_jit_file_to_libinfo_map_data[1]; +char* trick_vs_sim_control_panel_allocations[1]; +char* trick_vs_trick_view_allocations[1]; +char* trick_vs_malfunctions_trick_view_allocations[1]; +char* trick_vs_stripchart_allocations[1]; +char* trick_vs_monte_monitor_allocations[1]; +Trick::SimObject* dyn_integloop_integ_sched_sim_objects[1]; +std::string all_jobs_0__tags[1]; +std::string all_jobs_1__tags[1]; +std::string all_jobs_2__tags[1]; +std::string all_jobs_3__tags[1]; +std::string all_jobs_4__tags[1]; +std::string all_jobs_5__tags[1]; +std::string all_jobs_6__tags[1]; +std::string all_jobs_7__tags[1]; +std::string all_jobs_8__tags[1]; +std::string all_jobs_9__tags[1]; +std::string all_jobs_10__tags[1]; +std::string all_jobs_11__tags[1]; +std::string all_jobs_12__tags[1]; +std::string all_jobs_13__tags[1]; +std::string all_jobs_15__tags[1]; +std::string all_jobs_16__tags[1]; +std::string all_jobs_17__tags[1]; +std::string all_jobs_18__tags[1]; +std::string all_jobs_19__tags[1]; +std::string all_jobs_20__tags[1]; +std::string all_jobs_21__tags[1]; +std::string all_jobs_22__tags[1]; +std::string all_jobs_23__tags[1]; +std::string all_jobs_24__tags[1]; +std::string all_jobs_25__tags[1]; +std::string all_jobs_26__tags[1]; +std::string all_jobs_27__tags[1]; +std::string all_jobs_28__tags[1]; +std::string all_jobs_29__tags[1]; +std::string all_jobs_30__tags[1]; +std::string all_jobs_31__tags[1]; +std::string all_jobs_32__tags[1]; +std::string all_jobs_33__tags[1]; +std::string all_jobs_34__tags[1]; +std::string all_jobs_35__tags[1]; +std::string all_jobs_36__tags[1]; +std::string all_jobs_37__tags[1]; +std::string all_jobs_38__tags[1]; +std::string all_jobs_39__tags[1]; +std::string all_jobs_40__tags[1]; +std::string all_jobs_41__tags[1]; +std::string all_jobs_42__tags[1]; +std::string all_jobs_43__tags[1]; +std::string all_jobs_46__tags[1]; +std::string all_jobs_47__tags[1]; +std::string all_jobs_48__tags[1]; +std::string all_jobs_49__tags[1]; +std::string all_jobs_50__tags[1]; +std::string all_jobs_51__tags[1]; +std::string all_jobs_52__tags[1]; +std::string all_jobs_53__tags[1]; +std::string all_jobs_54__tags[1]; +std::string all_jobs_55__tags[1]; +std::string all_jobs_56__tags[1]; +std::string all_jobs_57__tags[1]; +std::string all_jobs_58__tags[1]; +std::string all_jobs_59__tags[1]; +std::string all_jobs_60__tags[1]; +std::string all_jobs_61__tags[1]; +std::string all_jobs_62__tags[1]; +std::string all_jobs_63__tags[1]; +std::string all_jobs_64__tags[1]; +std::string all_jobs_65__tags[1]; +std::string all_jobs_66__tags[1]; +std::string all_jobs_67__tags[1]; +std::string all_jobs_68__tags[1]; +std::string all_jobs_69__tags[1]; +std::string all_jobs_70__tags[1]; +std::string all_jobs_71__tags[1]; +std::string all_jobs_72__tags[1]; +std::string all_jobs_73__tags[1]; +std::string all_jobs_74__tags[1]; +std::string all_jobs_75__tags[1]; +std::string all_jobs_76__tags[1]; +std::string all_jobs_77__tags[1]; +std::string all_jobs_78__tags[1]; +std::string all_jobs_79__tags[1]; +std::string all_jobs_80__tags[1]; +std::string all_jobs_81__tags[1]; +std::string all_jobs_82__tags[1]; +std::string all_jobs_83__tags[1]; +std::string all_jobs_84__tags[1]; +std::string all_jobs_85__tags[1]; +std::string all_jobs_86__tags[1]; +std::string all_jobs_87__tags[1]; +std::string all_jobs_88__tags[1]; +std::string all_jobs_89__tags[1]; +std::string all_jobs_90__tags[1]; +std::string all_jobs_91__tags[1]; +std::string all_jobs_92__tags[1]; +std::string all_jobs_93__tags[1]; +std::string all_jobs_94__tags[1]; +std::string all_jobs_95__tags[1]; +std::string all_jobs_96__tags[1]; +std::string all_jobs_97__tags[1]; +std::string all_jobs_98__tags[1]; +std::string all_jobs_99__tags[1]; +std::string all_jobs_100__tags[1]; +std::string all_jobs_101__tags[1]; +std::string all_jobs_102__tags[1]; +std::string all_jobs_103__tags[1]; +std::string all_jobs_104__tags[1]; +std::string all_jobs_105__tags[1]; +std::string all_jobs_106__tags[1]; +std::string all_jobs_107__tags[1]; +std::string all_jobs_108__tags[1]; +std::string all_jobs_109__tags[1]; +std::string all_jobs_110__tags[1]; +std::string all_jobs_111__tags[1]; +std::string all_jobs_112__tags[1]; +std::string all_jobs_113__tags[1]; +std::string all_jobs_114__tags[1]; +std::string all_jobs_115__tags[1]; +std::string all_jobs_116__tags[1]; +std::string all_jobs_117__tags[1]; +std::string all_jobs_118__tags[1]; +std::string all_jobs_119__tags[1]; +std::string all_jobs_126__tags[1]; +std::string all_jobs_127__tags[1]; +std::string all_jobs_128__tags[1]; +std::string all_jobs_129__tags[1]; +std::string all_jobs_130__tags[1]; +std::string all_jobs_131__tags[1]; +std::string all_jobs_132__tags[1]; +std::string all_jobs_133__tags[1]; + + +// Clear all allocations to 0. +clear_all_vars(); + + +// Variable Assignments. +trick_sys.name = "trick_sys"; +trick_sys.id = 1; +trick_sys.sched.enable_freeze = true; +trick_sys.sched.stack_trace = true; +trick_sys.sched.trap_sigbus = true; +trick_sys.sched.trap_sigsegv = true; +trick_sys.sched.trap_sigabrt = true; +trick_sys.sched.initialization_complete = true; +trick_sys.sched.rt_nap = true; +trick_sys.sched.software_frame = 0.1; +trick_sys.sched.software_frame_tics = 100000; +trick_sys.sched.frame_count = 87; +trick_sys.sched.freeze_frame_count = 31; +// STL: trick_sys.sched.freeze_times +trick_sys.sched.freeze_frame = 1; +trick_sys.sched.freeze_frame_tics = 1000000; +trick_sys.sched.next_frame_check_tics = 8800000; +/* OUTPUT-ONLY: trick_sys.sched.mode = Freeze;*/ +trick_sys.sched.terminate_time = 9223372036854775806; +trick_sys.sched.time_tic_value = 1000000; +trick_sys.sched.old_time_tic_value = 1000000; +trick_sys.sched.time_tics = 8700000; +trick_sys.sched.freeze_time_tics = 31000000; +trick_sys.sched.next_freeze_frame_check_tics = 32000000; +trick_sys.sched.freeze_command = true; +trick_sys.sched.time_last_pass_tics = 8600000; +trick_sys.sched.job_call_time_tics = 100000; +trick_sys.sched.num_classes = 14; +trick_sys.sched.num_all_jobs = 134; +trick_sys.sched.all_jobs_for_checkpoint = &all_jobs[0]; +trick_sys.sched.num_sim_objects = 23; +// STL: trick_sys.sched.sim_objects +trick_sys.sched.version_date_tag = "@(#)CP Version 19.8.0-beta, Fri Mar 1 22:36:39 2024"; +trick_sys.sched.build_date = "Fri Mar 1 22:36:39 2024"; +trick_sys.sched.current_version = "19.8.0-beta"; + +trick_mc.name = "trick_mc"; +trick_mc.id = 2; +trick_mc.mc.timeout = 120; +trick_mc.mc.max_tries = 2; +trick_mc.mc.verbosity = Trick::MonteCarlo::MC_INFORMATIONAL; +trick_mc.mc.listen_device.disable_handshaking = TC_COMM_TRUE; +trick_mc.mc.connection_device.disable_handshaking = TC_COMM_TRUE; +trick_mc.mc.machine_name = "DESKTOP-2N4NH4J"; +trick_mc.mc.master_init_queue.list_size = 1; +trick_mc.mc.master_init_queue.next_job_time = 9223372036854775807; +trick_mc.mc.master_pre_queue.next_job_time = 9223372036854775807; +trick_mc.mc.master_post_queue.next_job_time = 9223372036854775807; +trick_mc.mc.master_shutdown_queue.next_job_time = 9223372036854775807; +trick_mc.mc.slave_init_queue.list_size = 1; +trick_mc.mc.slave_init_queue.next_job_time = 9223372036854775807; +trick_mc.mc.slave_pre_queue.next_job_time = 9223372036854775807; +trick_mc.mc.slave_post_queue.next_job_time = 9223372036854775807; +trick_mc.mc.slave_shutdown_queue.next_job_time = 9223372036854775807; + +trick_mm.name = "trick_mm"; +trick_mm.id = 3; +trick_mm.mm.restore_stls_default = true; +trick_mm.mm.local_anon_var_prefix = "trick_anon_local_"; +trick_mm.mm.extern_anon_var_prefix = "trick_anon_extern_"; +trick_mm.mm.reduced_checkpoint = true; + +trick_cpr.name = "trick_cpr"; +trick_cpr.id = 4; +// STL: trick_cpr.cpr.checkpoint_times +trick_cpr.cpr.safestore_time = 9223372036854775807; +trick_cpr.cpr.cpu_num = -1; + +trick_sie.name = "trick_sie"; +trick_sie.id = 5; + +trick_cmd_args.name = "trick_cmd_args"; +trick_cmd_args.id = 6; +trick_cmd_args.cmd_args.default_dir = "/home/frozone/trick/trick_sims/SIM_basic"; +trick_cmd_args.cmd_args.cmdline_name = "S_main_Linux_11.4_x86_64.exe"; +trick_cmd_args.cmd_args.run_dir = "RUN_test"; +trick_cmd_args.cmd_args.output_dir = "RUN_test"; +trick_cmd_args.cmd_args.input_file = "RUN_test/input2.py"; + +trick_message.name = "trick_message"; +trick_message.id = 7; +// STL: trick_message.mpublisher.subscribers +trick_message.mpublisher.tics_per_sec = 1000000; +trick_message.mpublisher.num_digits = 6; +trick_message.mpublisher.print_format = + {'|', 'L', ' ', '%', '3', 'd', '|', '%', 's', '|', '%', 's', '|', '%', 's', '|', 'T', ' ', '%', + 'd', '|', '%', 'l', 'l', 'd', '.', '%', '0', '6', 'l', 'l', 'd', '|', ' ', '\x0', '\x0', '\x0', '\x0', '\x0', + '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', '\x0', + '\x0', '\x0', '\x0', '\x0', '\x0'}; +trick_message.mpublisher.sim_name = " "; +trick_message.mcout.enabled = true; +trick_message.mcout.color = true; +trick_message.mcout.name = "cout"; +trick_message.mtcout.enabled = true; +trick_message.mtcout.color = true; +trick_message.mtcout.MessageSubscriber::name = "threadedcout"; +trick_message.mtcout.SysThread::ThreadBase::name = "threadedcout"; +trick_message.mtcout.max_buffer_items = 400; +trick_message.mtcout.max_buffer_size = 4000; +trick_message.mfile.enabled = true; +trick_message.mfile.name = "file"; +trick_message.mfile.file_name = "send_hs"; +trick_message.mdevice.enabled = true; +trick_message.mdevice.color = true; +trick_message.mdevice.name = "tcdevice"; +trick_message.mdevice.port = 40673; +trick_message.mdevice.listen_thread.name = "MessageListen"; +trick_message.pfile.enabled = true; +trick_message.pfile.name = "varserver_log"; +trick_message.pfile.file_name = "varserver_log"; +trick_message.message_file_manager.enabled = true; +trick_message.message_file_manager.color = true; +// STL: trick_message.message_file_manager._custom_message_files + +trick_jit.name = "trick_jit"; +trick_jit.id = 8; +// STL: trick_jit.jit.file_to_libinfo_map + +trick_ip.name = "trick_ip"; +trick_ip.id = 9; +trick_ip.ip.input_file = "RUN_test/input2.py"; +trick_ip.ip.units_conversion_msgs = true; +trick_ip.mtv.dummy_event.name = "no_name_specified"; +trick_ip.mtv.dummy_event.cycle = 1; +trick_ip.mtv.dummy_event.cycle_tics = 1000000; +trick_ip.mtv.dummy_event.target_inst = 1; +trick_ip.mtv.dummy_event.is_user_event = true; +trick_ip.mtv.dummy_event.fired_time = -1; +trick_ip.mtv.dummy_event.ran_time = -1; + +trick_em.name = "trick_em"; +trick_em.id = 10; + +trick_vs.name = "trick_vs"; +trick_vs.id = 11; +trick_vs.vs.enabled = true; +trick_vs.vs.listen_thread.name = "VarServListen"; +trick_vs.vs.listen_thread._requested_source_address = "DESKTOP-2N4NH4J"; +trick_vs.vs.listen_thread._requested_port = 44111; +trick_vs.vs.listen_thread._broadcast = true; +trick_vs.sim_control_panel.command = "/home/frozone/trick/bin/trick-simcontrol"; +trick_vs.sim_control_panel.command_c_str = &trick_anon_local_0[0]; +// STL: trick_vs.sim_control_panel.allocations +trick_vs.trick_view.command = "/home/frozone/trick/bin/trick-tv"; +trick_vs.trick_view.command_c_str = &trick_anon_local_1[0]; +// STL: trick_vs.trick_view.allocations +trick_vs.malfunctions_trick_view.command = "/home/frozone/trick/bin/trick-mtv"; +trick_vs.malfunctions_trick_view.command_c_str = &trick_anon_local_2[0]; +// STL: trick_vs.malfunctions_trick_view.allocations +trick_vs.stripchart.command = "/home/frozone/trick/bin/trick-stripchart"; +trick_vs.stripchart.command_c_str = &trick_anon_local_3[0]; +// STL: trick_vs.stripchart.allocations +trick_vs.monte_monitor.command = "/home/frozone/trick/bin/trick-mm"; +trick_vs.monte_monitor.command_c_str = &trick_anon_local_4[0]; +// STL: trick_vs.monte_monitor.allocations + +trick_data_record.name = "trick_data_record"; +trick_data_record.id = 12; +trick_data_record.drd.drd_writer_thread.name = "DR_Writer"; + +trick_real_time.name = "trick_real_time"; +trick_real_time.id = 13; +trick_real_time.gtod_clock.name = "GetTimeOfDay - CLOCK_REALTIME"; +trick_real_time.gtod_clock.clock_tics_per_sec = 1000000; +trick_real_time.gtod_clock.rt_clock_ratio = 1; +trick_real_time.gtod_clock.sim_tic_ratio = 1; +trick_real_time.itimer.enabled = true; +trick_real_time.itimer.active = true; +trick_real_time.rt_sync.active = true; +trick_real_time.rt_sync.freeze_frame = 1000000; +trick_real_time.rt_sync.freeze_time_tics = 38700000; +trick_real_time.rt_sync.rt_max_overrun_cnt = 100000000; +trick_real_time.rt_sync.rt_max_overrun_time = 1e+37; +trick_real_time.rt_sync.rt_max_overrun_time_tics = 9223372036854775807; +trick_real_time.rt_sync.frame_sched_time = 100002; +trick_real_time.rt_sync.frame_time = 0.100002; +trick_real_time.rt_sync.frame_overrun_time = -99939; +trick_real_time.rt_sync.frame_overrun = -0.099939; +trick_real_time.rt_sync.last_clock_time = 8600061; +trick_real_time.rt_sync.tics_per_sec = 1000000; +trick_real_time.rt_sync.align_tic_mult = 1; +trick_real_time.rt_sync.rt_clock = &trick_real_time.gtod_clock; +trick_real_time.rt_sync.default_clock = &trick_real_time.gtod_clock; +trick_real_time.rt_sync.sleep_timer = &trick_real_time.itimer; +trick_real_time.rt_sync.sim_start_time = 1709354237647948; +trick_real_time.rt_sync.sim_end_init_time = 1709354237892211; +trick_real_time.rt_sync.actual_run_ratio = 1; + +trick_frame_log.name = "trick_frame_log"; +trick_frame_log.id = 14; +trick_frame_log.frame_log.drg_trick = &trick_frame_trick_jobs; +trick_frame_log.frame_log.drg_frame = &trick_frame; +trick_frame_log.frame_log.plots_per_page = 6; + +trick_master_slave.name = "trick_master_slave"; +trick_master_slave.id = 15; + +trick_instruments.name = "trick_instruments"; +trick_instruments.id = 16; + +trick_inject.name = "trick_inject"; +trick_inject.id = 17; + +trick_zero_conf.name = "trick_zero_conf"; +trick_zero_conf.id = 18; +trick_zero_conf.zc.name = "My Sim!!!"; +trick_zero_conf.zc.type = "_trick-vs._tcp"; + +trick_utest.name = "trick_utest"; +trick_utest.id = 19; +trick_utest.unit_tests.exit_code_enabled = true; +trick_utest.unit_tests.name = "AllTests"; + +trick_udunits.name = "trick_udunits"; +trick_udunits.id = 20; + +dyn.name = "dyn"; +dyn.id = 21; +dyn.basic.counter = 87; + +dyn_integloop.name = "dyn_integloop"; +dyn_integloop.id = 22; +dyn_integloop.integ_sched.integ_ptr = &trick_anon_local_5[0]; +// STL: dyn_integloop.integ_sched.sim_objects +dyn_integloop.integ_sched.nominal_cycle = 0.1; +dyn_integloop.integ_sched.next_cycle = 0.1; +dyn_integloop.integ_sched.parent_sim_object = &dyn_integloop; +dyn_integloop.integ_sched.pre_integ_jobs.next_job_time = 9223372036854775807; +dyn_integloop.integ_sched.deriv_jobs.next_job_time = 9223372036854775807; +dyn_integloop.integ_sched.integ_jobs.list_size = 1; +dyn_integloop.integ_sched.integ_jobs.curr_index = 1; +dyn_integloop.integ_sched.integ_jobs.next_job_time = 9223372036854775807; +dyn_integloop.integ_sched.dynamic_event_jobs.next_job_time = 9223372036854775807; +dyn_integloop.integ_sched.post_integ_jobs.next_job_time = 9223372036854775807; + +trick_injector_executor_0.name = "trick_injector_executor_0"; +trick_injector_executor_0.id = 23; +trick_injector_executor_0.rtie.frame_multiple = 1; + +trick_frame_userjobs_main.name = "trick_data_record_group_frame_userjobs_main"; +trick_frame_userjobs_main.record = true; +trick_frame_userjobs_main.group_name = "frame_userjobs_main"; +trick_frame_userjobs_main.cycle = 0.1; +trick_frame_userjobs_main.max_num = 100000; +trick_frame_userjobs_main.byte_order = "little_endian"; +trick_frame_userjobs_main.job_class = "end_of_frame"; + +trick_frame_trick_jobs.name = "trick_data_record_group_frame_trickjobs"; +trick_frame_trick_jobs.record = true; +trick_frame_trick_jobs.group_name = "frame_trickjobs"; +trick_frame_trick_jobs.cycle = 0.1; +trick_frame_trick_jobs.max_num = 100000; +trick_frame_trick_jobs.byte_order = "little_endian"; +trick_frame_trick_jobs.job_class = "end_of_frame"; + +trick_frame.name = "trick_data_record_group_frame"; +trick_frame.record = true; +trick_frame.group_name = "frame"; +trick_frame.cycle = 0.1; +trick_frame.max_num = 100000; +trick_frame.byte_order = "little_endian"; +trick_frame.job_class = "end_of_frame"; + +trick_anon_local_0 = "/home/frozone/trick/bin/"; + +trick_anon_local_1 = "/home/frozone/trick/bin/"; + +trick_anon_local_2 = "/home/frozone/trick/bin/"; + +trick_anon_local_3 = "/home/frozone/trick/bin/"; + +trick_anon_local_4 = "/home/frozone/trick/bin/"; + +trick_anon_local_5[0].num_state = 4; +trick_anon_local_5[0].first_step_deriv = true; +trick_anon_local_5[0].dt = 0.1; +trick_anon_local_5[0].state = &trick_anon_local_10[0]; +trick_anon_local_5[0].deriv = &trick_anon_local_11[0]; +trick_anon_local_5[0].deriv2 = &trick_anon_local_12[0]; +trick_anon_local_5[0].state_ws = &trick_anon_local_13[0]; +trick_anon_local_5[0].time = 8.6; +trick_anon_local_5[0].integ_constructor = &trick_anon_local_5[0].helper_integ_constructor; +trick_anon_local_5[0].integ_interface = &trick_anon_local_5[0] + 88; +trick_anon_local_5[0].time_interface = &trick_anon_local_5[0] + 96; +trick_anon_local_5[0].integ_controls = &trick_anon_local_6[0]; +trick_anon_local_5[0].cached_derivs = &trick_anon_local_8[0]; +trick_anon_local_5[0].cached_state = &trick_anon_local_10[0]; +trick_anon_local_5[0].cached_accel = &trick_anon_local_8[2]; +trick_anon_local_5[0].cached_velocity = &trick_anon_local_10[2]; +trick_anon_local_5[0].cached_position = &trick_anon_local_10[0]; +trick_anon_local_5[0].er7_deriv = &trick_anon_local_8[0]; +trick_anon_local_5[0].er7_deriv2 = &trick_anon_local_9[0]; +trick_anon_local_5[0].trick_integ_constructor = &trick_anon_local_5[0].helper_integ_constructor; +trick_anon_local_5[0].first_order_integrator = &trick_anon_local_14[0]; +trick_anon_local_5[0].second_order_integrator = &trick_anon_local_17[0]; +trick_anon_local_5[0].buf_size = 4; +trick_anon_local_5[0].half_state_size = 2; +trick_anon_local_5[0].default_first_step_deriv = true; + +trick_anon_local_6[0].transition_table = &trick_anon_local_7[0]; +trick_anon_local_6[0].final_stage = 4; +trick_anon_local_6[0].number_stages = 4; +trick_anon_local_6[0].reset_needed = true; + +trick_anon_local_7 = + {1, 2, 3, 4}; + + + + +trick_anon_local_11 = + {&trick_anon_local_8[0], &trick_anon_local_8[0], &trick_anon_local_8[0], &trick_anon_local_8[0]}; + +trick_anon_local_12 = + {&trick_anon_local_9[0], &trick_anon_local_9[0], &trick_anon_local_9[0], &trick_anon_local_9[0]}; + +trick_anon_local_13 = + {&trick_anon_local_10[0], &trick_anon_local_10[0], &trick_anon_local_10[0], &trick_anon_local_10[0]}; + +trick_anon_local_14[0].state_size = 4; +trick_anon_local_14[0].init_state = &trick_anon_local_15[0]; +trick_anon_local_14[0].deriv_hist = + {&trick_anon_local_16[0], &trick_anon_local_16[4], &trick_anon_local_16[8], &trick_anon_local_16[12]}; + + + +trick_anon_local_17[0].state_size = + {2, 2}; +trick_anon_local_17[0].problem_type = er7_utils::Integration::SimpleSecondOrderODE; +trick_anon_local_17[0].init_pos = &trick_anon_local_18[0]; +trick_anon_local_17[0].init_vel = &trick_anon_local_19[0]; +trick_anon_local_17[0].posdot_hist = + {&trick_anon_local_20[0], &trick_anon_local_20[2], &trick_anon_local_20[4], &trick_anon_local_20[6]}; +trick_anon_local_17[0].veldot_hist = + {&trick_anon_local_21[0], &trick_anon_local_21[2], &trick_anon_local_21[4], &trick_anon_local_21[6]}; + + + + + +trick_anon_local_22 = + {&trick_anon_local_23[0], &trick_anon_local_24[0]}; + +trick_anon_local_23 = "./S_main_Linux_11.4_x86_64.exe"; + +trick_anon_local_24 = "RUN_test/input2.py"; + +trick_anon_local_25 = "/home/frozone/trick/bin/"; + +all_jobs[0].name = "trick_sys.sched.get_freeze_job"; +all_jobs[0].handled = true; +all_jobs[0].cycle = 1; +all_jobs[0].stop = 1e+37; +all_jobs[0].job_class_name = "default_data"; +all_jobs[0].phase = 60000; +// STL: all_jobs[0].tags +all_jobs[0].sim_object_id = 1; +all_jobs[1].name = "trick_sys.exec_collect_init"; +all_jobs[1].handled = true; +all_jobs[1].cycle = 1; +all_jobs[1].stop = 1e+37; +all_jobs[1].job_class = 2; +all_jobs[1].job_class_name = "initialization"; +all_jobs[1].phase = 65534; +// STL: all_jobs[1].tags +all_jobs[1].id = 1; +all_jobs[1].sim_object_id = 1; +all_jobs[2].name = "trick_sys.sched.write_s_run_summary"; +all_jobs[2].handled = true; +all_jobs[2].cycle = 1; +all_jobs[2].stop = 1e+37; +all_jobs[2].job_class = 2; +all_jobs[2].job_class_name = "initialization"; +all_jobs[2].phase = 65534; +// STL: all_jobs[2].tags +all_jobs[2].id = 2; +all_jobs[2].sim_object_id = 1; +all_jobs[3].name = "trick_sys.sched.check_all_jobs_handled"; +all_jobs[3].handled = true; +all_jobs[3].cycle = 1; +all_jobs[3].stop = 1e+37; +all_jobs[3].job_class = 2; +all_jobs[3].job_class_name = "initialization"; +all_jobs[3].phase = 65535; +// STL: all_jobs[3].tags +all_jobs[3].id = 3; +all_jobs[3].sim_object_id = 1; +all_jobs[4].name = "trick_sys.sched.check_all_job_cycle_times"; +all_jobs[4].handled = true; +all_jobs[4].cycle = 1; +all_jobs[4].stop = 1e+37; +all_jobs[4].job_class = 2; +all_jobs[4].job_class_name = "initialization"; +all_jobs[4].phase = 65535; +// STL: all_jobs[4].tags +all_jobs[4].id = 4; +all_jobs[4].sim_object_id = 1; +all_jobs[5].name = "trick_sys.sched.create_threads"; +all_jobs[5].handled = true; +all_jobs[5].cycle = 1; +all_jobs[5].stop = 1e+37; +all_jobs[5].job_class = 2; +all_jobs[5].job_class_name = "initialization"; +all_jobs[5].phase = 65535; +// STL: all_jobs[5].tags +all_jobs[5].id = 5; +all_jobs[5].sim_object_id = 1; +all_jobs[6].name = "trick_sys.sched.write_s_job_execution"; +all_jobs[6].handled = true; +all_jobs[6].cycle = 1; +all_jobs[6].stop = 1e+37; +all_jobs[6].job_class = 2; +all_jobs[6].job_class_name = "initialization"; +all_jobs[6].phase = 65535; +// STL: all_jobs[6].tags +all_jobs[6].id = 6; +all_jobs[6].sim_object_id = 1; +all_jobs[7].name = "trick_sys.sched.async_freeze_to_exec_command"; +all_jobs[7].handled = true; +all_jobs[7].cycle = 1; +all_jobs[7].stop = 1e+37; +all_jobs[7].job_class = 2; +all_jobs[7].job_class_name = "initialization"; +all_jobs[7].phase = 65535; +// STL: all_jobs[7].tags +all_jobs[7].id = 7; +all_jobs[7].sim_object_id = 1; +all_jobs[8].name = "trick_sys.sched.checkpoint"; +all_jobs[8].handled = true; +all_jobs[8].cycle = 1; +all_jobs[8].stop = 1e+37; +all_jobs[8].job_class_name = "checkpoint"; +// STL: all_jobs[8].tags +all_jobs[8].id = 8; +all_jobs[8].sim_object_id = 1; +all_jobs[9].name = "trick_sys.sched.post_checkpoint"; +all_jobs[9].handled = true; +all_jobs[9].cycle = 1; +all_jobs[9].stop = 1e+37; +all_jobs[9].job_class = 1; +all_jobs[9].job_class_name = "post_checkpoint"; +// STL: all_jobs[9].tags +all_jobs[9].id = 9; +all_jobs[9].sim_object_id = 1; +all_jobs[10].name = "trick_sys.exec_collect_init"; +all_jobs[10].handled = true; +all_jobs[10].cycle = 1; +all_jobs[10].stop = 1e+37; +all_jobs[10].job_class = 3; +all_jobs[10].job_class_name = "restart"; +all_jobs[10].phase = 65534; +// STL: all_jobs[10].tags +all_jobs[10].id = 10; +all_jobs[10].sim_object_id = 1; +all_jobs[11].name = "trick_sys.sched.sched_freeze_to_exec_command"; +all_jobs[11].handled = true; +all_jobs[11].cycle = 1; +all_jobs[11].stop = 1e+37; +all_jobs[11].job_class = 1016; +all_jobs[11].job_class_name = "system_moding"; +all_jobs[11].system_job_class = 1; +all_jobs[11].phase = 60000; +// STL: all_jobs[11].tags +all_jobs[11].id = 11; +all_jobs[11].sim_object_id = 1; +all_jobs[11].cycle_tics = 1000000; +all_jobs[11].stop_tics = 9223372036854775807; +all_jobs[11].next_tics = 9223372036854775807; +all_jobs[12].name = "trick_sys.sched.sched_freeze_to_exec_command"; +all_jobs[12].handled = true; +all_jobs[12].cycle = 1; +all_jobs[12].stop = 1e+37; +all_jobs[12].job_class = 6; +all_jobs[12].job_class_name = "end_of_frame"; +all_jobs[12].phase = 60000; +// STL: all_jobs[12].tags +all_jobs[12].id = 12; +all_jobs[12].sim_object_id = 1; +all_jobs[13].name = "trick_sys.sched.async_freeze_to_exec_command"; +all_jobs[13].handled = true; +all_jobs[13].cycle = 1; +all_jobs[13].stop = 1e+37; +all_jobs[13].job_class = 6; +all_jobs[13].job_class_name = "end_of_frame"; +all_jobs[13].phase = 60000; +// STL: all_jobs[13].tags +all_jobs[13].id = 13; +all_jobs[13].sim_object_id = 1; +all_jobs[14].name = "trick_sys.sched.init_freeze_scheduled"; +all_jobs[14].handled = true; +all_jobs[14].cycle = 1; +all_jobs[14].stop = 1e+37; +all_jobs[14].job_class = 8; +all_jobs[14].job_class_name = "freeze_init"; +all_jobs[14].phase = 60000; +// STL: all_jobs[14].tags +all_jobs[14].id = 14; +all_jobs[14].sim_object_id = 1; +all_jobs[15].name = "trick_sys.sched.advance_sim_time"; +all_jobs[15].handled = true; +all_jobs[15].cycle = 1; +all_jobs[15].stop = 1e+37; +all_jobs[15].job_class = 1015; +all_jobs[15].job_class_name = "system_advance_sim_time"; +all_jobs[15].system_job_class = 1; +all_jobs[15].phase = 60000; +// STL: all_jobs[15].tags +all_jobs[15].id = 15; +all_jobs[15].sim_object_id = 1; +all_jobs[15].cycle_tics = 1000000; +all_jobs[15].stop_tics = 9223372036854775807; +all_jobs[15].next_tics = 8700000; +all_jobs[16].name = "trick_sys.sched.thread_sync"; +all_jobs[16].handled = true; +all_jobs[16].cycle = 1; +all_jobs[16].stop = 1e+37; +all_jobs[16].job_class = 4; +all_jobs[16].job_class_name = "system_thread_sync"; +all_jobs[16].system_job_class = 1; +all_jobs[16].phase = 60000; +// STL: all_jobs[16].tags +all_jobs[16].id = 16; +all_jobs[16].sim_object_id = 1; +all_jobs[17].name = "trick_mc.mc.process_sim_args"; +all_jobs[17].handled = true; +all_jobs[17].cycle = 1; +all_jobs[17].stop = 1e+37; +all_jobs[17].job_class_name = "default_data"; +// STL: all_jobs[17].tags +all_jobs[17].sim_object_id = 2; +all_jobs[18].name = "trick_mc.mc.execute_monte"; +all_jobs[18].handled = true; +all_jobs[18].cycle = 1; +all_jobs[18].stop = 1e+37; +all_jobs[18].job_class = 2; +all_jobs[18].job_class_name = "initialization"; +all_jobs[18].phase = 1; +// STL: all_jobs[18].tags +all_jobs[18].id = 1; +all_jobs[18].sim_object_id = 2; +all_jobs[19].name = "trick_mc.mc.shutdown"; +all_jobs[19].handled = true; +all_jobs[19].cycle = 1; +all_jobs[19].stop = 1e+37; +all_jobs[19].job_class = 7; +all_jobs[19].job_class_name = "shutdown"; +all_jobs[19].phase = 60000; +// STL: all_jobs[19].tags +all_jobs[19].id = 2; +all_jobs[19].sim_object_id = 2; +all_jobs[20].name = "trick_cpr.cpr.find_write_checkpoint_jobs"; +all_jobs[20].handled = true; +all_jobs[20].cycle = 1; +all_jobs[20].stop = 1e+37; +all_jobs[20].job_class_name = "default_data"; +// STL: all_jobs[20].tags +all_jobs[20].sim_object_id = 4; +all_jobs[21].name = "trick_cpr.cpr.write_pre_init_checkpoint"; +all_jobs[21].handled = true; +all_jobs[21].cycle = 1; +all_jobs[21].stop = 1e+37; +all_jobs[21].job_class = 2; +all_jobs[21].job_class_name = "initialization"; +all_jobs[21].phase = 1; +// STL: all_jobs[21].tags +all_jobs[21].id = 1; +all_jobs[21].sim_object_id = 4; +all_jobs[22].name = "trick_cpr.cpr.write_post_init_checkpoint"; +all_jobs[22].handled = true; +all_jobs[22].cycle = 1; +all_jobs[22].stop = 1e+37; +all_jobs[22].job_class = 2; +all_jobs[22].job_class_name = "initialization"; +all_jobs[22].phase = 65535; +// STL: all_jobs[22].tags +all_jobs[22].id = 2; +all_jobs[22].sim_object_id = 4; +all_jobs[23].name = "trick_cpr.cpr.write_checkpoint"; +all_jobs[23].handled = true; +all_jobs[23].cycle = 1; +all_jobs[23].stop = 1e+37; +all_jobs[23].job_class = 1014; +all_jobs[23].job_class_name = "system_checkpoint"; +all_jobs[23].system_job_class = 1; +// STL: all_jobs[23].tags +all_jobs[23].id = 3; +all_jobs[23].sim_object_id = 4; +all_jobs[23].cycle_tics = 1000000; +all_jobs[23].stop_tics = 9223372036854775807; +all_jobs[23].next_tics = 9223372036854775807; +all_jobs[24].name = "trick_cpr.cpr.safestore_checkpoint"; +all_jobs[24].handled = true; +all_jobs[24].cycle = 1; +all_jobs[24].stop = 1e+37; +all_jobs[24].job_class = 1014; +all_jobs[24].job_class_name = "system_checkpoint"; +all_jobs[24].system_job_class = 1; +// STL: all_jobs[24].tags +all_jobs[24].id = 4; +all_jobs[24].sim_object_id = 4; +all_jobs[24].cycle_tics = 1000000; +all_jobs[24].stop_tics = 9223372036854775807; +all_jobs[24].next_tics = 9223372036854775807; +all_jobs[25].name = "trick_cpr.cpr.write_end_checkpoint"; +all_jobs[25].handled = true; +all_jobs[25].cycle = 1; +all_jobs[25].stop = 1e+37; +all_jobs[25].job_class = 7; +all_jobs[25].job_class_name = "shutdown"; +// STL: all_jobs[25].tags +all_jobs[25].id = 5; +all_jobs[25].sim_object_id = 4; +all_jobs[26].name = "trick_cpr.cpr.load_checkpoint_job"; +all_jobs[26].handled = true; +all_jobs[26].cycle = 1; +all_jobs[26].stop = 1e+37; +all_jobs[26].job_class = 11; +all_jobs[26].job_class_name = "freeze"; +// STL: all_jobs[26].tags +all_jobs[26].id = 6; +all_jobs[26].sim_object_id = 4; +all_jobs[27].name = "trick_cpr.cpr.load_checkpoint_job"; +all_jobs[27].handled = true; +all_jobs[27].cycle = 1; +all_jobs[27].stop = 1e+37; +all_jobs[27].job_class = 6; +all_jobs[27].job_class_name = "end_of_frame"; +// STL: all_jobs[27].tags +all_jobs[27].id = 7; +all_jobs[27].sim_object_id = 4; +all_jobs[28].name = "trick_sie.sie.process_sim_args"; +all_jobs[28].handled = true; +all_jobs[28].cycle = 1; +all_jobs[28].stop = 1e+37; +all_jobs[28].job_class_name = "default_data"; +// STL: all_jobs[28].tags +all_jobs[28].sim_object_id = 5; +all_jobs[29].name = "trick_message.mpublisher.subscribe"; +all_jobs[29].handled = true; +all_jobs[29].cycle = 1; +all_jobs[29].stop = 1e+37; +all_jobs[29].job_class_name = "default_data"; +all_jobs[29].phase = 60000; +// STL: all_jobs[29].tags +all_jobs[29].sim_object_id = 7; +all_jobs[30].name = "trick_message.mpublisher.subscribe"; +all_jobs[30].handled = true; +all_jobs[30].cycle = 1; +all_jobs[30].stop = 1e+37; +all_jobs[30].job_class_name = "default_data"; +all_jobs[30].phase = 60000; +// STL: all_jobs[30].tags +all_jobs[30].id = 1; +all_jobs[30].sim_object_id = 7; +all_jobs[31].name = "trick_message.mpublisher.subscribe"; +all_jobs[31].handled = true; +all_jobs[31].cycle = 1; +all_jobs[31].stop = 1e+37; +all_jobs[31].job_class_name = "default_data"; +all_jobs[31].phase = 60000; +// STL: all_jobs[31].tags +all_jobs[31].id = 2; +all_jobs[31].sim_object_id = 7; +all_jobs[32].name = "trick_message.mpublisher.subscribe"; +all_jobs[32].handled = true; +all_jobs[32].cycle = 1; +all_jobs[32].stop = 1e+37; +all_jobs[32].job_class_name = "default_data"; +all_jobs[32].phase = 60000; +// STL: all_jobs[32].tags +all_jobs[32].id = 3; +all_jobs[32].sim_object_id = 7; +all_jobs[33].name = "trick_message.mpublisher.subscribe"; +all_jobs[33].handled = true; +all_jobs[33].cycle = 1; +all_jobs[33].stop = 1e+37; +all_jobs[33].job_class_name = "default_data"; +all_jobs[33].phase = 60000; +// STL: all_jobs[33].tags +all_jobs[33].id = 4; +all_jobs[33].sim_object_id = 7; +all_jobs[34].name = "trick_message.mdevice.default_data"; +all_jobs[34].handled = true; +all_jobs[34].cycle = 1; +all_jobs[34].stop = 1e+37; +all_jobs[34].job_class_name = "default_data"; +all_jobs[34].phase = 60000; +// STL: all_jobs[34].tags +all_jobs[34].id = 5; +all_jobs[34].sim_object_id = 7; +all_jobs[35].name = "trick_message.mpublisher.init"; +all_jobs[35].handled = true; +all_jobs[35].cycle = 1; +all_jobs[35].stop = 1e+37; +all_jobs[35].job_class = 2; +all_jobs[35].job_class_name = "initialization"; +all_jobs[35].phase = 1; +// STL: all_jobs[35].tags +all_jobs[35].id = 6; +all_jobs[35].sim_object_id = 7; +all_jobs[36].name = "trick_message.mfile.init"; +all_jobs[36].handled = true; +all_jobs[36].cycle = 1; +all_jobs[36].stop = 1e+37; +all_jobs[36].job_class = 2; +all_jobs[36].job_class_name = "initialization"; +all_jobs[36].phase = 1; +// STL: all_jobs[36].tags +all_jobs[36].id = 7; +all_jobs[36].sim_object_id = 7; +all_jobs[37].name = "trick_message.pfile.init"; +all_jobs[37].handled = true; +all_jobs[37].cycle = 1; +all_jobs[37].stop = 1e+37; +all_jobs[37].job_class = 2; +all_jobs[37].job_class_name = "initialization"; +all_jobs[37].phase = 1; +// STL: all_jobs[37].tags +all_jobs[37].id = 8; +all_jobs[37].sim_object_id = 7; +all_jobs[38].name = "trick_message.mdevice.init"; +all_jobs[38].handled = true; +all_jobs[38].cycle = 1; +all_jobs[38].stop = 1e+37; +all_jobs[38].job_class = 2; +all_jobs[38].job_class_name = "initialization"; +all_jobs[38].phase = 1; +// STL: all_jobs[38].tags +all_jobs[38].id = 9; +all_jobs[38].sim_object_id = 7; +all_jobs[39].name = "trick_message.mpublisher.init"; +all_jobs[39].handled = true; +all_jobs[39].cycle = 1; +all_jobs[39].stop = 1e+37; +all_jobs[39].job_class = 13; +all_jobs[39].job_class_name = "exec_time_tic_changed"; +all_jobs[39].phase = 60000; +// STL: all_jobs[39].tags +all_jobs[39].id = 10; +all_jobs[39].sim_object_id = 7; +all_jobs[40].name = "trick_message.mdevice.restart"; +all_jobs[40].handled = true; +all_jobs[40].cycle = 1; +all_jobs[40].stop = 1e+37; +all_jobs[40].job_class = 3; +all_jobs[40].job_class_name = "restart"; +all_jobs[40].phase = 1; +// STL: all_jobs[40].tags +all_jobs[40].id = 11; +all_jobs[40].sim_object_id = 7; +all_jobs[41].name = "trick_message.message_file_manager.restart"; +all_jobs[41].handled = true; +all_jobs[41].cycle = 1; +all_jobs[41].stop = 1e+37; +all_jobs[41].job_class = 3; +all_jobs[41].job_class_name = "restart"; +all_jobs[41].phase = 1; +// STL: all_jobs[41].tags +all_jobs[41].id = 12; +all_jobs[41].sim_object_id = 7; +all_jobs[42].name = "trick_message.mtcout.shutdown"; +all_jobs[42].handled = true; +all_jobs[42].cycle = 1; +all_jobs[42].stop = 1e+37; +all_jobs[42].job_class = 7; +all_jobs[42].job_class_name = "shutdown"; +all_jobs[42].phase = 60000; +// STL: all_jobs[42].tags +all_jobs[42].id = 13; +all_jobs[42].sim_object_id = 7; +all_jobs[43].name = "trick_message.mdevice.shutdown"; +all_jobs[43].handled = true; +all_jobs[43].cycle = 1; +all_jobs[43].stop = 1e+37; +all_jobs[43].job_class = 7; +all_jobs[43].job_class_name = "shutdown"; +all_jobs[43].phase = 60000; +// STL: all_jobs[43].tags +all_jobs[43].id = 14; +all_jobs[43].sim_object_id = 7; +all_jobs[44].name = "trick_jit.jit.process_sim_args"; +all_jobs[44].handled = true; +all_jobs[44].cycle = 1; +all_jobs[44].stop = 1e+37; +all_jobs[44].job_class = 1; +all_jobs[44].job_class_name = "input_processor"; +all_jobs[44].phase = 50000; +// STL: all_jobs[44].tags +all_jobs[44].sim_object_id = 8; +all_jobs[45].name = "trick_jit.jit.init"; +all_jobs[45].handled = true; +all_jobs[45].cycle = 1; +all_jobs[45].stop = 1e+37; +all_jobs[45].job_class = 1; +all_jobs[45].job_class_name = "input_processor"; +all_jobs[45].phase = 50000; +// STL: all_jobs[45].tags +all_jobs[45].id = 1; +all_jobs[45].sim_object_id = 8; +all_jobs[46].name = "trick_ip.ip.process_sim_args"; +all_jobs[46].handled = true; +all_jobs[46].cycle = 1; +all_jobs[46].stop = 1e+37; +all_jobs[46].job_class = 1; +all_jobs[46].job_class_name = "input_processor"; +all_jobs[46].phase = 60000; +// STL: all_jobs[46].tags +all_jobs[46].sim_object_id = 9; +all_jobs[47].name = "trick_ip.ip.init"; +all_jobs[47].handled = true; +all_jobs[47].cycle = 1; +all_jobs[47].stop = 1e+37; +all_jobs[47].job_class = 1; +all_jobs[47].job_class_name = "input_processor"; +all_jobs[47].phase = 60000; +// STL: all_jobs[47].tags +all_jobs[47].id = 1; +all_jobs[47].sim_object_id = 9; +all_jobs[48].name = "trick_ip.ip.restart"; +all_jobs[48].handled = true; +all_jobs[48].cycle = 1; +all_jobs[48].stop = 1e+37; +all_jobs[48].job_class = 3; +all_jobs[48].job_class_name = "restart"; +all_jobs[48].phase = 60000; +// STL: all_jobs[48].tags +all_jobs[48].id = 2; +all_jobs[48].sim_object_id = 9; +all_jobs[49].name = "trick_ip.ip.shutdown"; +all_jobs[49].handled = true; +all_jobs[49].cycle = 1; +all_jobs[49].stop = 1e+37; +all_jobs[49].job_class = 7; +all_jobs[49].job_class_name = "shutdown"; +all_jobs[49].phase = 65535; +// STL: all_jobs[49].tags +all_jobs[49].id = 3; +all_jobs[49].sim_object_id = 9; +all_jobs[50].name = "trick_em.create_thread_process_event"; +all_jobs[50].handled = true; +all_jobs[50].cycle = 1; +all_jobs[50].stop = 1e+37; +all_jobs[50].job_class_name = "default_data"; +all_jobs[50].phase = 60000; +// STL: all_jobs[50].tags +all_jobs[50].sim_object_id = 10; +all_jobs[51].name = "trick_em.ep.add_pending_events"; +all_jobs[51].handled = true; +all_jobs[51].cycle = 1; +all_jobs[51].stop = 1e+37; +all_jobs[51].job_class = 2; +all_jobs[51].job_class_name = "initialization"; +all_jobs[51].phase = 65535; +// STL: all_jobs[51].tags +all_jobs[51].id = 1; +all_jobs[51].sim_object_id = 10; +all_jobs[52].name = "trick_em.ep.add_pending_events"; +all_jobs[52].handled = true; +all_jobs[52].cycle = 1; +all_jobs[52].stop = 1e+37; +all_jobs[52].job_class = 3; +all_jobs[52].job_class_name = "restart"; +all_jobs[52].phase = 65535; +// STL: all_jobs[52].tags +all_jobs[52].id = 2; +all_jobs[52].sim_object_id = 10; +all_jobs[53].name = "trick_em.ep.add_pending_events"; +all_jobs[53].handled = true; +all_jobs[53].cycle = 1; +all_jobs[53].stop = 1e+37; +all_jobs[53].job_class = 5; +all_jobs[53].job_class_name = "top_of_frame"; +all_jobs[53].phase = 60000; +// STL: all_jobs[53].tags +all_jobs[53].id = 3; +all_jobs[53].sim_object_id = 10; +all_jobs[54].name = "trick_em.ep.process_event"; +all_jobs[54].handled = true; +all_jobs[54].cycle = 1; +all_jobs[54].stop = 1e+37; +all_jobs[54].job_class = 3; +all_jobs[54].job_class_name = "input_processor_run"; +all_jobs[54].system_job_class = 1; +all_jobs[54].phase = 60000; +// STL: all_jobs[54].tags +all_jobs[54].id = 4; +all_jobs[54].sim_object_id = 10; +all_jobs[54].next_tics = 9223372036854775807; +all_jobs[55].name = "trick_em.em.time_tic_changed"; +all_jobs[55].handled = true; +all_jobs[55].cycle = 1; +all_jobs[55].stop = 1e+37; +all_jobs[55].job_class = 13; +all_jobs[55].job_class_name = "exec_time_tic_changed"; +all_jobs[55].phase = 60000; +// STL: all_jobs[55].tags +all_jobs[55].id = 5; +all_jobs[55].sim_object_id = 10; +all_jobs[56].name = "trick_em.em.preload_checkpoint"; +all_jobs[56].handled = true; +all_jobs[56].cycle = 1; +all_jobs[56].stop = 1e+37; +all_jobs[56].job_class = 2; +all_jobs[56].job_class_name = "preload_checkpoint"; +all_jobs[56].phase = 60000; +// STL: all_jobs[56].tags +all_jobs[56].id = 6; +all_jobs[56].sim_object_id = 10; +all_jobs[57].name = "trick_em.ep.preload_checkpoint"; +all_jobs[57].handled = true; +all_jobs[57].cycle = 1; +all_jobs[57].stop = 1e+37; +all_jobs[57].job_class = 2; +all_jobs[57].job_class_name = "preload_checkpoint"; +all_jobs[57].phase = 60000; +// STL: all_jobs[57].tags +all_jobs[57].id = 7; +all_jobs[57].sim_object_id = 10; +all_jobs[58].name = "trick_em.em.restart"; +all_jobs[58].handled = true; +all_jobs[58].cycle = 1; +all_jobs[58].stop = 1e+37; +all_jobs[58].job_class = 3; +all_jobs[58].job_class_name = "restart"; +all_jobs[58].phase = 60000; +// STL: all_jobs[58].tags +all_jobs[58].id = 8; +all_jobs[58].sim_object_id = 10; +all_jobs[59].name = "trick_vs.vs.default_data"; +all_jobs[59].handled = true; +all_jobs[59].cycle = 1; +all_jobs[59].stop = 1e+37; +all_jobs[59].job_class_name = "default_data"; +all_jobs[59].phase = 60000; +// STL: all_jobs[59].tags +all_jobs[59].sim_object_id = 11; +all_jobs[60].name = "trick_vs.vs.init"; +all_jobs[60].handled = true; +all_jobs[60].cycle = 1; +all_jobs[60].stop = 1e+37; +all_jobs[60].job_class = 2; +all_jobs[60].job_class_name = "initialization"; +// STL: all_jobs[60].tags +all_jobs[60].id = 1; +all_jobs[60].sim_object_id = 11; +all_jobs[61].name = "trick_vs.vs.init"; +all_jobs[61].handled = true; +all_jobs[61].cycle = 1; +all_jobs[61].stop = 1e+37; +all_jobs[61].job_class_name = "monte_master_init"; +all_jobs[61].phase = 60000; +// STL: all_jobs[61].tags +all_jobs[61].id = 2; +all_jobs[61].sim_object_id = 11; +all_jobs[62].name = "trick_vs.monte_carlo_disable_all_apps"; +all_jobs[62].handled = true; +all_jobs[62].cycle = 1; +all_jobs[62].stop = 1e+37; +all_jobs[62].job_class = 2; +all_jobs[62].job_class_name = "initialization"; +all_jobs[62].phase = 1; +// STL: all_jobs[62].tags +all_jobs[62].id = 3; +all_jobs[62].sim_object_id = 11; +all_jobs[63].name = "trick_vs.Trick::launch_all_external_applications"; +all_jobs[63].handled = true; +all_jobs[63].cycle = 1; +all_jobs[63].stop = 1e+37; +all_jobs[63].job_class = 2; +all_jobs[63].job_class_name = "initialization"; +all_jobs[63].phase = 1; +// STL: all_jobs[63].tags +all_jobs[63].id = 4; +all_jobs[63].sim_object_id = 11; +all_jobs[64].name = "trick_vs.vs.suspendPreCheckpointReload"; +all_jobs[64].handled = true; +all_jobs[64].cycle = 1; +all_jobs[64].stop = 1e+37; +all_jobs[64].job_class = 2; +all_jobs[64].job_class_name = "preload_checkpoint"; +all_jobs[64].phase = 60000; +// STL: all_jobs[64].tags +all_jobs[64].id = 5; +all_jobs[64].sim_object_id = 11; +all_jobs[65].name = "trick_vs.vs.restart"; +all_jobs[65].handled = true; +all_jobs[65].cycle = 1; +all_jobs[65].stop = 1e+37; +all_jobs[65].job_class = 3; +all_jobs[65].job_class_name = "restart"; +all_jobs[65].phase = 60000; +// STL: all_jobs[65].tags +all_jobs[65].id = 6; +all_jobs[65].sim_object_id = 11; +all_jobs[66].name = "trick_vs.vs.resumePostCheckpointReload"; +all_jobs[66].handled = true; +all_jobs[66].cycle = 1; +all_jobs[66].stop = 1e+37; +all_jobs[66].job_class = 3; +all_jobs[66].job_class_name = "restart"; +all_jobs[66].phase = 60000; +// STL: all_jobs[66].tags +all_jobs[66].id = 7; +all_jobs[66].sim_object_id = 11; +all_jobs[67].name = "trick_vs.vs.copy_and_write_top"; +all_jobs[67].handled = true; +all_jobs[67].cycle = 1; +all_jobs[67].stop = 1e+37; +all_jobs[67].job_class = 5; +all_jobs[67].job_class_name = "top_of_frame"; +all_jobs[67].phase = 60000; +// STL: all_jobs[67].tags +all_jobs[67].id = 8; +all_jobs[67].sim_object_id = 11; +all_jobs[68].name = "trick_vs.vs.copy_and_write_scheduled"; +all_jobs[68].handled = true; +all_jobs[68].cycle = 1; +all_jobs[68].stop = 1e+37; +all_jobs[68].job_class = 1011; +all_jobs[68].job_class_name = "automatic_last"; +all_jobs[68].system_job_class = 1; +all_jobs[68].phase = 60000; +// STL: all_jobs[68].tags +all_jobs[68].id = 9; +all_jobs[68].sim_object_id = 11; +all_jobs[68].cycle_tics = 1000000; +all_jobs[68].stop_tics = 9223372036854775807; +all_jobs[68].next_tics = 9223372036854775807; +all_jobs[69].name = "trick_vs.vs.freeze_init"; +all_jobs[69].handled = true; +all_jobs[69].cycle = 1; +all_jobs[69].stop = 1e+37; +all_jobs[69].job_class = 8; +all_jobs[69].job_class_name = "freeze_init"; +all_jobs[69].phase = 60000; +// STL: all_jobs[69].tags +all_jobs[69].id = 10; +all_jobs[69].sim_object_id = 11; +all_jobs[70].name = "trick_vs.vs.copy_and_write_freeze_scheduled"; +all_jobs[70].handled = true; +all_jobs[70].cycle = 1; +all_jobs[70].stop = 1e+37; +all_jobs[70].job_class = 10; +all_jobs[70].job_class_name = "freeze_automatic"; +all_jobs[70].system_job_class = 1; +all_jobs[70].phase = 60000; +// STL: all_jobs[70].tags +all_jobs[70].id = 11; +all_jobs[70].sim_object_id = 11; +all_jobs[70].next_tics = 9223372036854775807; +all_jobs[71].name = "trick_vs.vs.copy_and_write_freeze"; +all_jobs[71].handled = true; +all_jobs[71].cycle = 1; +all_jobs[71].stop = 1e+37; +all_jobs[71].job_class = 11; +all_jobs[71].job_class_name = "freeze"; +all_jobs[71].phase = 60000; +// STL: all_jobs[71].tags +all_jobs[71].id = 12; +all_jobs[71].sim_object_id = 11; +all_jobs[72].name = "trick_vs.vs.shutdown"; +all_jobs[72].handled = true; +all_jobs[72].cycle = 1; +all_jobs[72].stop = 1e+37; +all_jobs[72].job_class = 7; +all_jobs[72].job_class_name = "shutdown"; +all_jobs[72].phase = 60000; +// STL: all_jobs[72].tags +all_jobs[72].id = 13; +all_jobs[72].sim_object_id = 11; +all_jobs[73].name = "trick_data_record.drd.remove_files"; +all_jobs[73].handled = true; +all_jobs[73].cycle = 1; +all_jobs[73].stop = 1e+37; +all_jobs[73].job_class = 2; +all_jobs[73].job_class_name = "initialization"; +all_jobs[73].phase = 1; +// STL: all_jobs[73].tags +all_jobs[73].sim_object_id = 12; +all_jobs[74].name = "trick_data_record.drd.init"; +all_jobs[74].handled = true; +all_jobs[74].cycle = 1; +all_jobs[74].stop = 1e+37; +all_jobs[74].job_class = 2; +all_jobs[74].job_class_name = "initialization"; +all_jobs[74].phase = 65534; +// STL: all_jobs[74].tags +all_jobs[74].id = 1; +all_jobs[74].sim_object_id = 12; +all_jobs[75].name = "trick_data_record.drd.remove_files"; +all_jobs[75].handled = true; +all_jobs[75].cycle = 1; +all_jobs[75].stop = 1e+37; +all_jobs[75].job_class = 4; +all_jobs[75].job_class_name = "monte_slave_init"; +all_jobs[75].phase = 60000; +// STL: all_jobs[75].tags +all_jobs[75].id = 2; +all_jobs[75].sim_object_id = 12; +all_jobs[76].name = "trick_data_record.drd.signal_thread"; +all_jobs[76].handled = true; +all_jobs[76].cycle = 1; +all_jobs[76].stop = 1e+37; +all_jobs[76].job_class = 6; +all_jobs[76].job_class_name = "end_of_frame"; +all_jobs[76].phase = 60000; +// STL: all_jobs[76].tags +all_jobs[76].id = 3; +all_jobs[76].sim_object_id = 12; +all_jobs[77].name = "trick_data_record.drd.preload_checkpoint"; +all_jobs[77].handled = true; +all_jobs[77].cycle = 1; +all_jobs[77].stop = 1e+37; +all_jobs[77].job_class = 2; +all_jobs[77].job_class_name = "preload_checkpoint"; +all_jobs[77].phase = 60000; +// STL: all_jobs[77].tags +all_jobs[77].id = 4; +all_jobs[77].sim_object_id = 12; +all_jobs[78].name = "trick_data_record.drd.restart"; +all_jobs[78].handled = true; +all_jobs[78].cycle = 1; +all_jobs[78].stop = 1e+37; +all_jobs[78].job_class = 3; +all_jobs[78].job_class_name = "restart"; +all_jobs[78].phase = 60000; +// STL: all_jobs[78].tags +all_jobs[78].id = 5; +all_jobs[78].sim_object_id = 12; +all_jobs[79].name = "trick_data_record.drd.shutdown"; +all_jobs[79].handled = true; +all_jobs[79].cycle = 1; +all_jobs[79].stop = 1e+37; +all_jobs[79].job_class = 7; +all_jobs[79].job_class_name = "shutdown"; +all_jobs[79].phase = 60000; +// STL: all_jobs[79].tags +all_jobs[79].id = 6; +all_jobs[79].sim_object_id = 12; +all_jobs[80].name = "trick_real_time.rt_sync.get_sim_start_time"; +all_jobs[80].handled = true; +all_jobs[80].cycle = 1; +all_jobs[80].stop = 1e+37; +all_jobs[80].job_class_name = "default_data"; +// STL: all_jobs[80].tags +all_jobs[80].sim_object_id = 13; +all_jobs[81].name = "trick_real_time.rt_sync.rt_clock->calc_sim_time_ratio"; +all_jobs[81].handled = true; +all_jobs[81].cycle = 1; +all_jobs[81].stop = 1e+37; +all_jobs[81].job_class = 2; +all_jobs[81].job_class_name = "initialization"; +all_jobs[81].phase = 65535; +// STL: all_jobs[81].tags +all_jobs[81].id = 1; +all_jobs[81].sim_object_id = 13; +all_jobs[82].name = "trick_real_time.rt_sync.initialize"; +all_jobs[82].handled = true; +all_jobs[82].cycle = 1; +all_jobs[82].stop = 1e+37; +all_jobs[82].job_class = 2; +all_jobs[82].job_class_name = "initialization"; +all_jobs[82].phase = 65535; +// STL: all_jobs[82].tags +all_jobs[82].id = 2; +all_jobs[82].sim_object_id = 13; +all_jobs[83].name = "trick_real_time.rt_sync.start_realtime"; +all_jobs[83].handled = true; +all_jobs[83].cycle = 1; +all_jobs[83].stop = 1e+37; +all_jobs[83].job_class = 2; +all_jobs[83].job_class_name = "initialization"; +all_jobs[83].phase = 65535; +// STL: all_jobs[83].tags +all_jobs[83].id = 3; +all_jobs[83].sim_object_id = 13; +all_jobs[84].name = "trick_real_time.rt_sync.get_sim_end_init_time"; +all_jobs[84].handled = true; +all_jobs[84].cycle = 1; +all_jobs[84].stop = 1e+37; +all_jobs[84].job_class = 2; +all_jobs[84].job_class_name = "initialization"; +all_jobs[84].phase = 65535; +// STL: all_jobs[84].tags +all_jobs[84].id = 4; +all_jobs[84].sim_object_id = 13; +all_jobs[85].name = "trick_real_time.rt_sync.restart"; +all_jobs[85].handled = true; +all_jobs[85].cycle = 1; +all_jobs[85].stop = 1e+37; +all_jobs[85].job_class = 3; +all_jobs[85].job_class_name = "restart"; +all_jobs[85].phase = 65535; +// STL: all_jobs[85].tags +all_jobs[85].id = 5; +all_jobs[85].sim_object_id = 13; +all_jobs[86].name = "trick_real_time.rt_sync.freeze_init"; +all_jobs[86].handled = true; +all_jobs[86].cycle = 1; +all_jobs[86].stop = 1e+37; +all_jobs[86].job_class = 8; +all_jobs[86].job_class_name = "freeze_init"; +all_jobs[86].phase = 60000; +// STL: all_jobs[86].tags +all_jobs[86].id = 6; +all_jobs[86].sim_object_id = 13; +all_jobs[87].name = "trick_real_time.rt_sync.freeze_pause"; +all_jobs[87].handled = true; +all_jobs[87].cycle = 1; +all_jobs[87].stop = 1e+37; +all_jobs[87].job_class = 11; +all_jobs[87].job_class_name = "freeze"; +all_jobs[87].phase = 65535; +// STL: all_jobs[87].tags +all_jobs[87].id = 7; +all_jobs[87].sim_object_id = 13; +all_jobs[88].name = "trick_real_time.rt_sync.unfreeze"; +all_jobs[88].handled = true; +all_jobs[88].cycle = 1; +all_jobs[88].stop = 1e+37; +all_jobs[88].job_class = 12; +all_jobs[88].job_class_name = "unfreeze"; +all_jobs[88].phase = 60000; +// STL: all_jobs[88].tags +all_jobs[88].id = 8; +all_jobs[88].sim_object_id = 13; +all_jobs[89].name = "trick_real_time.rt_sync.rt_monitor"; +all_jobs[89].handled = true; +all_jobs[89].cycle = 1; +all_jobs[89].stop = 1e+37; +all_jobs[89].job_class = 6; +all_jobs[89].job_class_name = "end_of_frame"; +all_jobs[89].phase = 65535; +// STL: all_jobs[89].tags +all_jobs[89].id = 9; +all_jobs[89].sim_object_id = 13; +all_jobs[90].name = "trick_real_time.rt_sync.get_sim_end_time"; +all_jobs[90].handled = true; +all_jobs[90].cycle = 1; +all_jobs[90].stop = 1e+37; +all_jobs[90].job_class = 7; +all_jobs[90].job_class_name = "shutdown"; +all_jobs[90].phase = 65535; +// STL: all_jobs[90].tags +all_jobs[90].id = 10; +all_jobs[90].sim_object_id = 13; +all_jobs[91].name = "trick_real_time.rt_sync.shutdown"; +all_jobs[91].handled = true; +all_jobs[91].cycle = 1; +all_jobs[91].stop = 1e+37; +all_jobs[91].job_class = 7; +all_jobs[91].job_class_name = "shutdown"; +all_jobs[91].phase = 65535; +// STL: all_jobs[91].tags +all_jobs[91].id = 11; +all_jobs[91].sim_object_id = 13; +all_jobs[92].name = "trick_frame_log.frame_log.frame_clock_start"; +all_jobs[92].handled = true; +all_jobs[92].cycle = 1; +all_jobs[92].stop = 1e+37; +all_jobs[92].job_class = -1; +all_jobs[92].job_class_name = "instrumentation"; +// STL: all_jobs[92].tags +all_jobs[92].sim_object_id = 14; +all_jobs[93].name = "trick_frame_log.frame_log.frame_clock_stop"; +all_jobs[93].handled = true; +all_jobs[93].cycle = 1; +all_jobs[93].stop = 1e+37; +all_jobs[93].job_class = -1; +all_jobs[93].job_class_name = "instrumentation"; +all_jobs[93].phase = 65535; +// STL: all_jobs[93].tags +all_jobs[93].id = 1; +all_jobs[93].sim_object_id = 14; +all_jobs[94].name = "trick_frame_log.frame_log.default_data"; +all_jobs[94].handled = true; +all_jobs[94].cycle = 1; +all_jobs[94].stop = 1e+37; +all_jobs[94].job_class_name = "default_data"; +all_jobs[94].phase = 60000; +// STL: all_jobs[94].tags +all_jobs[94].id = 2; +all_jobs[94].sim_object_id = 14; +all_jobs[95].name = "trick_frame_log.frame_log.create_DP_files"; +all_jobs[95].handled = true; +all_jobs[95].cycle = 1; +all_jobs[95].stop = 1e+37; +all_jobs[95].job_class = 2; +all_jobs[95].job_class_name = "initialization"; +all_jobs[95].phase = 60000; +// STL: all_jobs[95].tags +all_jobs[95].id = 3; +all_jobs[95].sim_object_id = 14; +all_jobs[96].name = "trick_frame_log.frame_log.clear_data_record_info"; +all_jobs[96].handled = true; +all_jobs[96].cycle = 1; +all_jobs[96].stop = 1e+37; +all_jobs[96].job_class = 3; +all_jobs[96].job_class_name = "restart"; +all_jobs[96].phase = 60000; +// STL: all_jobs[96].tags +all_jobs[96].id = 4; +all_jobs[96].sim_object_id = 14; +all_jobs[97].name = "trick_frame_log.frame_log.restart"; +all_jobs[97].handled = true; +all_jobs[97].cycle = 1; +all_jobs[97].stop = 1e+37; +all_jobs[97].job_class = 3; +all_jobs[97].job_class_name = "restart"; +all_jobs[97].phase = 65535; +// STL: all_jobs[97].tags +all_jobs[97].id = 5; +all_jobs[97].sim_object_id = 14; +all_jobs[98].name = "trick_frame_log.frame_log.shutdown"; +all_jobs[98].handled = true; +all_jobs[98].cycle = 1; +all_jobs[98].stop = 1e+37; +all_jobs[98].job_class = 7; +all_jobs[98].job_class_name = "shutdown"; +all_jobs[98].phase = 65535; +// STL: all_jobs[98].tags +all_jobs[98].id = 6; +all_jobs[98].sim_object_id = 14; +all_jobs[99].name = "trick_master_slave.master.process_sim_args"; +all_jobs[99].handled = true; +all_jobs[99].cycle = 1; +all_jobs[99].stop = 1e+37; +all_jobs[99].job_class = 2; +all_jobs[99].job_class_name = "initialization"; +// STL: all_jobs[99].tags +all_jobs[99].sim_object_id = 15; +all_jobs[100].name = "trick_master_slave.slave.process_sim_args"; +all_jobs[100].handled = true; +all_jobs[100].cycle = 1; +all_jobs[100].stop = 1e+37; +all_jobs[100].job_class = 2; +all_jobs[100].job_class_name = "initialization"; +// STL: all_jobs[100].tags +all_jobs[100].id = 1; +all_jobs[100].sim_object_id = 15; +all_jobs[101].name = "trick_master_slave.master.init"; +all_jobs[101].handled = true; +all_jobs[101].cycle = 1; +all_jobs[101].stop = 1e+37; +all_jobs[101].job_class = 2; +all_jobs[101].job_class_name = "initialization"; +// STL: all_jobs[101].tags +all_jobs[101].id = 2; +all_jobs[101].sim_object_id = 15; +all_jobs[102].name = "trick_master_slave.slave.init"; +all_jobs[102].handled = true; +all_jobs[102].cycle = 1; +all_jobs[102].stop = 1e+37; +all_jobs[102].job_class = 2; +all_jobs[102].job_class_name = "initialization"; +// STL: all_jobs[102].tags +all_jobs[102].id = 3; +all_jobs[102].sim_object_id = 15; +all_jobs[103].name = "trick_master_slave.master.checkpoint"; +all_jobs[103].handled = true; +all_jobs[103].cycle = 1; +all_jobs[103].stop = 1e+37; +all_jobs[103].job_class_name = "checkpoint"; +all_jobs[103].phase = 60000; +// STL: all_jobs[103].tags +all_jobs[103].id = 4; +all_jobs[103].sim_object_id = 15; +all_jobs[104].name = "trick_master_slave.master.preload_checkpoint"; +all_jobs[104].handled = true; +all_jobs[104].cycle = 1; +all_jobs[104].stop = 1e+37; +all_jobs[104].job_class = 2; +all_jobs[104].job_class_name = "preload_checkpoint"; +all_jobs[104].phase = 60000; +// STL: all_jobs[104].tags +all_jobs[104].id = 5; +all_jobs[104].sim_object_id = 15; +all_jobs[105].name = "trick_master_slave.master.end_of_frame_status_from_slave"; +all_jobs[105].handled = true; +all_jobs[105].cycle = 1; +all_jobs[105].stop = 1e+37; +all_jobs[105].job_class = 6; +all_jobs[105].job_class_name = "end_of_frame"; +all_jobs[105].phase = 65534; +// STL: all_jobs[105].tags +all_jobs[105].id = 6; +all_jobs[105].sim_object_id = 15; +all_jobs[106].name = "trick_master_slave.master.end_of_frame_status_to_slave"; +all_jobs[106].handled = true; +all_jobs[106].cycle = 1; +all_jobs[106].stop = 1e+37; +all_jobs[106].job_class = 6; +all_jobs[106].job_class_name = "end_of_frame"; +all_jobs[106].phase = 65535; +// STL: all_jobs[106].tags +all_jobs[106].id = 7; +all_jobs[106].sim_object_id = 15; +all_jobs[107].name = "trick_master_slave.slave.end_of_frame"; +all_jobs[107].handled = true; +all_jobs[107].cycle = 1; +all_jobs[107].stop = 1e+37; +all_jobs[107].job_class = 6; +all_jobs[107].job_class_name = "end_of_frame"; +all_jobs[107].phase = 65534; +// STL: all_jobs[107].tags +all_jobs[107].id = 8; +all_jobs[107].sim_object_id = 15; +all_jobs[108].name = "trick_master_slave.master.freeze_init"; +all_jobs[108].handled = true; +all_jobs[108].cycle = 1; +all_jobs[108].stop = 1e+37; +all_jobs[108].job_class = 8; +all_jobs[108].job_class_name = "freeze_init"; +all_jobs[108].phase = 65535; +// STL: all_jobs[108].tags +all_jobs[108].id = 9; +all_jobs[108].sim_object_id = 15; +all_jobs[109].name = "trick_master_slave.slave.freeze_init"; +all_jobs[109].handled = true; +all_jobs[109].cycle = 1; +all_jobs[109].stop = 1e+37; +all_jobs[109].job_class = 8; +all_jobs[109].job_class_name = "freeze_init"; +all_jobs[109].phase = 65535; +// STL: all_jobs[109].tags +all_jobs[109].id = 10; +all_jobs[109].sim_object_id = 15; +all_jobs[110].name = "trick_master_slave.master.freeze"; +all_jobs[110].handled = true; +all_jobs[110].cycle = 1; +all_jobs[110].stop = 1e+37; +all_jobs[110].job_class = 11; +all_jobs[110].job_class_name = "freeze"; +all_jobs[110].phase = 65535; +// STL: all_jobs[110].tags +all_jobs[110].id = 11; +all_jobs[110].sim_object_id = 15; +all_jobs[111].name = "trick_master_slave.slave.freeze"; +all_jobs[111].handled = true; +all_jobs[111].cycle = 1; +all_jobs[111].stop = 1e+37; +all_jobs[111].job_class = 11; +all_jobs[111].job_class_name = "freeze"; +all_jobs[111].phase = 65535; +// STL: all_jobs[111].tags +all_jobs[111].id = 12; +all_jobs[111].sim_object_id = 15; +all_jobs[112].name = "trick_master_slave.master.unfreeze"; +all_jobs[112].handled = true; +all_jobs[112].cycle = 1; +all_jobs[112].stop = 1e+37; +all_jobs[112].job_class = 12; +all_jobs[112].job_class_name = "unfreeze"; +all_jobs[112].phase = 65535; +// STL: all_jobs[112].tags +all_jobs[112].id = 13; +all_jobs[112].sim_object_id = 15; +all_jobs[113].name = "trick_master_slave.slave.unfreeze"; +all_jobs[113].handled = true; +all_jobs[113].cycle = 1; +all_jobs[113].stop = 1e+37; +all_jobs[113].job_class = 12; +all_jobs[113].job_class_name = "unfreeze"; +all_jobs[113].phase = 65535; +// STL: all_jobs[113].tags +all_jobs[113].id = 14; +all_jobs[113].sim_object_id = 15; +all_jobs[114].name = "trick_master_slave.master.shutdown"; +all_jobs[114].handled = true; +all_jobs[114].cycle = 1; +all_jobs[114].stop = 1e+37; +all_jobs[114].job_class = 7; +all_jobs[114].job_class_name = "shutdown"; +all_jobs[114].phase = 65534; +// STL: all_jobs[114].tags +all_jobs[114].id = 15; +all_jobs[114].sim_object_id = 15; +all_jobs[115].name = "trick_master_slave.slave.shutdown"; +all_jobs[115].handled = true; +all_jobs[115].cycle = 1; +all_jobs[115].stop = 1e+37; +all_jobs[115].job_class = 7; +all_jobs[115].job_class_name = "shutdown"; +all_jobs[115].phase = 65534; +// STL: all_jobs[115].tags +all_jobs[115].id = 16; +all_jobs[115].sim_object_id = 15; +all_jobs[116].name = "trick_instruments.echo_jobs.echo_job"; +all_jobs[116].handled = true; +all_jobs[116].cycle = 1; +all_jobs[116].stop = 1e+37; +all_jobs[116].job_class = -1; +all_jobs[116].job_class_name = "instrumentation"; +all_jobs[116].phase = 60000; +// STL: all_jobs[116].tags +all_jobs[116].sim_object_id = 16; +all_jobs[117].name = "trick_instruments.debug_pause.debug_pause"; +all_jobs[117].handled = true; +all_jobs[117].cycle = 1; +all_jobs[117].stop = 1e+37; +all_jobs[117].job_class = -1; +all_jobs[117].job_class_name = "instrumentation"; +all_jobs[117].phase = 60000; +// STL: all_jobs[117].tags +all_jobs[117].id = 1; +all_jobs[117].sim_object_id = 16; +all_jobs[118].name = "trick_inject.create_injector_executors"; +all_jobs[118].handled = true; +all_jobs[118].cycle = 1; +all_jobs[118].stop = 1e+37; +all_jobs[118].job_class_name = "default_data"; +// STL: all_jobs[118].tags +all_jobs[118].sim_object_id = 17; +all_jobs[119].name = "trick_zero_conf.zc.init"; +all_jobs[119].handled = true; +all_jobs[119].cycle = 1; +all_jobs[119].stop = 1e+37; +all_jobs[119].job_class = 2; +all_jobs[119].job_class_name = "initialization"; +all_jobs[119].phase = 60000; +// STL: all_jobs[119].tags +all_jobs[119].sim_object_id = 18; +all_jobs[120].name = "trick_utest.unit_tests.write_output"; +all_jobs[120].handled = true; +all_jobs[120].cycle = 1; +all_jobs[120].stop = 1e+37; +all_jobs[120].job_class = 7; +all_jobs[120].job_class_name = "shutdown"; +all_jobs[120].phase = 65535; +// STL: all_jobs[120].tags +all_jobs[120].sim_object_id = 19; +all_jobs[121].name = "trick_udunits.udunits.read_default_xml"; +all_jobs[121].handled = true; +all_jobs[121].cycle = 1; +all_jobs[121].stop = 1e+37; +all_jobs[121].job_class_name = "default_data"; +all_jobs[121].phase = 65535; +// STL: all_jobs[121].tags +all_jobs[121].sim_object_id = 20; +all_jobs[122].name = "dyn.basic.default_data"; +all_jobs[122].handled = true; +all_jobs[122].cycle = 1; +all_jobs[122].stop = 1e+37; +all_jobs[122].job_class_name = "default_data"; +all_jobs[122].phase = 60000; +// STL: all_jobs[122].tags +all_jobs[122].sim_object_id = 21; +all_jobs[123].name = "dyn.basic.state_init"; +all_jobs[123].handled = true; +all_jobs[123].cycle = 1; +all_jobs[123].stop = 1e+37; +all_jobs[123].job_class = 2; +all_jobs[123].job_class_name = "initialization"; +all_jobs[123].phase = 60000; +// STL: all_jobs[123].tags +all_jobs[123].id = 1; +all_jobs[123].sim_object_id = 21; +all_jobs[124].name = "dyn.basic.state_increment"; +all_jobs[124].handled = true; +all_jobs[124].cycle = 0.1; +all_jobs[124].stop = 1e+37; +all_jobs[124].job_class = 1007; +all_jobs[124].job_class_name = "scheduled"; +all_jobs[124].phase = 60000; +// STL: all_jobs[124].tags +all_jobs[124].id = 2; +all_jobs[124].sim_object_id = 21; +all_jobs[124].cycle_tics = 100000; +all_jobs[124].stop_tics = 9223372036854775807; +all_jobs[124].next_tics = 8700000; +all_jobs[125].name = "dyn.basic.state_integ"; +all_jobs[125].handled = true; +all_jobs[125].cycle = 1; +all_jobs[125].stop = 1e+37; +all_jobs[125].job_class = 2001; +all_jobs[125].job_class_name = "integration"; +all_jobs[125].phase = 60000; +// STL: all_jobs[125].tags +all_jobs[125].id = 3; +all_jobs[125].sim_object_id = 21; +all_jobs[126].name = "dyn_integloop.integ_sched.rebuild_jobs"; +all_jobs[126].handled = true; +all_jobs[126].cycle = 1; +all_jobs[126].stop = 1e+37; +all_jobs[126].job_class_name = "default_data"; +all_jobs[126].phase = 65534; +// STL: all_jobs[126].tags +all_jobs[126].sim_object_id = 22; +all_jobs[127].name = "dyn_integloop.integ_sched.get_first_step_deriv_from_integrator"; +all_jobs[127].handled = true; +all_jobs[127].cycle = 1; +all_jobs[127].stop = 1e+37; +all_jobs[127].job_class = 2; +all_jobs[127].job_class_name = "initialization"; +all_jobs[127].phase = 65535; +// STL: all_jobs[127].tags +all_jobs[127].id = 1; +all_jobs[127].sim_object_id = 22; +all_jobs[128].name = "dyn_integloop.integ_sched.call_deriv_jobs"; +all_jobs[128].handled = true; +all_jobs[128].cycle = 1; +all_jobs[128].stop = 1e+37; +all_jobs[128].job_class = 2; +all_jobs[128].job_class_name = "initialization"; +all_jobs[128].phase = 65535; +// STL: all_jobs[128].tags +all_jobs[128].id = 2; +all_jobs[128].sim_object_id = 22; +all_jobs[129].name = "dyn_integloop.integ_sched.integrate"; +all_jobs[129].handled = true; +all_jobs[129].cycle = 0.1; +all_jobs[129].stop = 1e+37; +all_jobs[129].job_class = 1017; +all_jobs[129].job_class_name = "integ_loop"; +all_jobs[129].phase = 60000; +// STL: all_jobs[129].tags +all_jobs[129].id = 3; +all_jobs[129].sim_object_id = 22; +all_jobs[129].cycle_tics = 100000; +all_jobs[129].stop_tics = 9223372036854775807; +all_jobs[129].next_tics = 8800000; +all_jobs[130].name = "dyn_integloop.integ_sched.restart_checkpoint"; +all_jobs[130].handled = true; +all_jobs[130].cycle = 1; +all_jobs[130].stop = 1e+37; +all_jobs[130].job_class = 2; +all_jobs[130].job_class_name = "preload_checkpoint"; +// STL: all_jobs[130].tags +all_jobs[130].id = 4; +all_jobs[130].sim_object_id = 22; +all_jobs[131].name = "dyn_integloop.integ_sched.rebuild_jobs"; +all_jobs[131].handled = true; +all_jobs[131].cycle = 1; +all_jobs[131].stop = 1e+37; +all_jobs[131].job_class = 3; +all_jobs[131].job_class_name = "restart"; +all_jobs[131].phase = 60000; +// STL: all_jobs[131].tags +all_jobs[131].id = 5; +all_jobs[131].sim_object_id = 22; +all_jobs[132].name = "dyn_integloop.integ_sched.get_first_step_deriv_from_integrator"; +all_jobs[132].handled = true; +all_jobs[132].cycle = 1; +all_jobs[132].stop = 1e+37; +all_jobs[132].job_class = 3; +all_jobs[132].job_class_name = "restart"; +all_jobs[132].phase = 65535; +// STL: all_jobs[132].tags +all_jobs[132].id = 6; +all_jobs[132].sim_object_id = 22; +all_jobs[133].name = "trick_injector_executor_0.rtie.Exec"; +all_jobs[133].handled = true; +all_jobs[133].cycle = 1; +all_jobs[133].stop = 1e+37; +all_jobs[133].job_class = 5; +all_jobs[133].job_class_name = "top_of_frame"; +all_jobs[133].phase = 60000; +// STL: all_jobs[133].tags +all_jobs[133].sim_object_id = 23; + +trick_sys_sched_sim_objects[0] = &trick_sys; +trick_sys_sched_sim_objects[1] = &trick_mc; +trick_sys_sched_sim_objects[2] = &trick_mm; +trick_sys_sched_sim_objects[3] = &trick_cpr; +trick_sys_sched_sim_objects[4] = &trick_sie; +trick_sys_sched_sim_objects[5] = &trick_cmd_args; +trick_sys_sched_sim_objects[6] = &trick_message; +trick_sys_sched_sim_objects[7] = &trick_jit; +trick_sys_sched_sim_objects[8] = &trick_ip; +trick_sys_sched_sim_objects[9] = &trick_em; +trick_sys_sched_sim_objects[10] = &trick_vs; +trick_sys_sched_sim_objects[11] = &trick_data_record; +trick_sys_sched_sim_objects[12] = &trick_real_time; +trick_sys_sched_sim_objects[13] = &trick_frame_log; +trick_sys_sched_sim_objects[14] = &trick_master_slave; +trick_sys_sched_sim_objects[15] = &trick_instruments; +trick_sys_sched_sim_objects[16] = &trick_inject; +trick_sys_sched_sim_objects[17] = &trick_zero_conf; +trick_sys_sched_sim_objects[18] = &trick_utest; +trick_sys_sched_sim_objects[19] = &trick_udunits; +trick_sys_sched_sim_objects[20] = &dyn; +trick_sys_sched_sim_objects[21] = &dyn_integloop; +trick_sys_sched_sim_objects[22] = &trick_injector_executor_0; + +trick_message_mpublisher_subscribers[0] = &trick_message.mcout; +trick_message_mpublisher_subscribers[1] = &trick_message.mfile; +trick_message_mpublisher_subscribers[2] = &trick_message.mdevice; +trick_message_mpublisher_subscribers[3] = &trick_message.pfile; +trick_message_mpublisher_subscribers[4] = &trick_message.message_file_manager; + +trick_jit_jit_file_to_libinfo_map_keys = + {"S_main"}; + +trick_jit_jit_file_to_libinfo_map_data[0].library_name = "S_main"; + +trick_vs_sim_control_panel_allocations = + {&trick_anon_local_0[0]}; + +trick_vs_trick_view_allocations = + {&trick_anon_local_1[0]}; + +trick_vs_malfunctions_trick_view_allocations = + {&trick_anon_local_2[0]}; + +trick_vs_stripchart_allocations = + {&trick_anon_local_3[0]}; + +trick_vs_monte_monitor_allocations = + {&trick_anon_local_4[0]}; + +dyn_integloop_integ_sched_sim_objects[0] = &dyn; + +all_jobs_0__tags = + {"TRK"}; + +all_jobs_1__tags = + {"TRK"}; + +all_jobs_2__tags = + {"TRK"}; + +all_jobs_3__tags = + {"TRK"}; + +all_jobs_4__tags = + {"TRK"}; + +all_jobs_5__tags = + {"TRK"}; + +all_jobs_6__tags = + {"TRK"}; + +all_jobs_7__tags = + {"TRK"}; + +all_jobs_8__tags = + {"TRK"}; + +all_jobs_9__tags = + {"TRK"}; + +all_jobs_10__tags = + {"TRK"}; + +all_jobs_11__tags = + {"TRK"}; + +all_jobs_12__tags = + {"TRK"}; + +all_jobs_13__tags = + {"TRK"}; + +all_jobs_15__tags = + {"TRK"}; + +all_jobs_16__tags = + {"TRK"}; + +all_jobs_17__tags = + {"TRK"}; + +all_jobs_18__tags = + {"TRK"}; + +all_jobs_19__tags = + {"TRK"}; + +all_jobs_20__tags = + {"TRK"}; + +all_jobs_21__tags = + {"TRK"}; + +all_jobs_22__tags = + {"TRK"}; + +all_jobs_23__tags = + {"TRK"}; + +all_jobs_24__tags = + {"TRK"}; + +all_jobs_25__tags = + {"TRK"}; + +all_jobs_26__tags = + {"TRK"}; + +all_jobs_27__tags = + {"TRK"}; + +all_jobs_28__tags = + {"TRK"}; + +all_jobs_29__tags = + {"TRK"}; + +all_jobs_30__tags = + {"TRK"}; + +all_jobs_31__tags = + {"TRK"}; + +all_jobs_32__tags = + {"TRK"}; + +all_jobs_33__tags = + {"TRK"}; + +all_jobs_34__tags = + {"TRK"}; + +all_jobs_35__tags = + {"TRK"}; + +all_jobs_36__tags = + {"TRK"}; + +all_jobs_37__tags = + {"TRK"}; + +all_jobs_38__tags = + {"TRK"}; + +all_jobs_39__tags = + {"TRK"}; + +all_jobs_40__tags = + {"TRK"}; + +all_jobs_41__tags = + {"TRK"}; + +all_jobs_42__tags = + {"TRK"}; + +all_jobs_43__tags = + {"TRK"}; + +all_jobs_46__tags = + {"TRK"}; + +all_jobs_47__tags = + {"TRK"}; + +all_jobs_48__tags = + {"TRK"}; + +all_jobs_49__tags = + {"TRK"}; + +all_jobs_50__tags = + {"TRK"}; + +all_jobs_51__tags = + {"TRK"}; + +all_jobs_52__tags = + {"TRK"}; + +all_jobs_53__tags = + {"TRK"}; + +all_jobs_54__tags = + {"TRK"}; + +all_jobs_55__tags = + {"TRK"}; + +all_jobs_56__tags = + {"TRK"}; + +all_jobs_57__tags = + {"TRK"}; + +all_jobs_58__tags = + {"TRK"}; + +all_jobs_59__tags = + {"TRK"}; + +all_jobs_60__tags = + {"TRK"}; + +all_jobs_61__tags = + {"TRK"}; + +all_jobs_62__tags = + {"TRK"}; + +all_jobs_63__tags = + {"TRK"}; + +all_jobs_64__tags = + {"TRK"}; + +all_jobs_65__tags = + {"TRK"}; + +all_jobs_66__tags = + {"TRK"}; + +all_jobs_67__tags = + {"TRK"}; + +all_jobs_68__tags = + {"TRK"}; + +all_jobs_69__tags = + {"TRK"}; + +all_jobs_70__tags = + {"TRK"}; + +all_jobs_71__tags = + {"TRK"}; + +all_jobs_72__tags = + {"TRK"}; + +all_jobs_73__tags = + {"TRK"}; + +all_jobs_74__tags = + {"TRK"}; + +all_jobs_75__tags = + {"TRK"}; + +all_jobs_76__tags = + {"TRK"}; + +all_jobs_77__tags = + {"TRK"}; + +all_jobs_78__tags = + {"TRK"}; + +all_jobs_79__tags = + {"TRK"}; + +all_jobs_80__tags = + {"TRK"}; + +all_jobs_81__tags = + {"TRK"}; + +all_jobs_82__tags = + {"TRK"}; + +all_jobs_83__tags = + {"TRK"}; + +all_jobs_84__tags = + {"TRK"}; + +all_jobs_85__tags = + {"TRK"}; + +all_jobs_86__tags = + {"TRK"}; + +all_jobs_87__tags = + {"TRK"}; + +all_jobs_88__tags = + {"TRK"}; + +all_jobs_89__tags = + {"TRK"}; + +all_jobs_90__tags = + {"TRK"}; + +all_jobs_91__tags = + {"TRK"}; + +all_jobs_92__tags = + {"TRK"}; + +all_jobs_93__tags = + {"TRK"}; + +all_jobs_94__tags = + {"TRK"}; + +all_jobs_95__tags = + {"TRK"}; + +all_jobs_96__tags = + {"TRK"}; + +all_jobs_97__tags = + {"TRK"}; + +all_jobs_98__tags = + {"TRK"}; + +all_jobs_99__tags = + {"TRK"}; + +all_jobs_100__tags = + {"TRK"}; + +all_jobs_101__tags = + {"TRK"}; + +all_jobs_102__tags = + {"TRK"}; + +all_jobs_103__tags = + {"TRK"}; + +all_jobs_104__tags = + {"TRK"}; + +all_jobs_105__tags = + {"TRK"}; + +all_jobs_106__tags = + {"TRK"}; + +all_jobs_107__tags = + {"TRK"}; + +all_jobs_108__tags = + {"TRK"}; + +all_jobs_109__tags = + {"TRK"}; + +all_jobs_110__tags = + {"TRK"}; + +all_jobs_111__tags = + {"TRK"}; + +all_jobs_112__tags = + {"TRK"}; + +all_jobs_113__tags = + {"TRK"}; + +all_jobs_114__tags = + {"TRK"}; + +all_jobs_115__tags = + {"TRK"}; + +all_jobs_116__tags = + {"TRK"}; + +all_jobs_117__tags = + {"TRK"}; + +all_jobs_118__tags = + {"TRK"}; + +all_jobs_119__tags = + {"TRK"}; + +all_jobs_126__tags = + {"TRK"}; + +all_jobs_127__tags = + {"TRK"}; + +all_jobs_128__tags = + {"TRK"}; + +all_jobs_129__tags = + {"TRK"}; + +all_jobs_130__tags = + {"TRK"}; + +all_jobs_131__tags = + {"TRK"}; + +all_jobs_132__tags = + {"TRK"}; + +all_jobs_133__tags = + {"TRK"}; \ No newline at end of file diff --git a/trick_source/java/Makefile b/trick_source/java/Makefile index 557c1bb6..045cc1e6 100644 --- a/trick_source/java/Makefile +++ b/trick_source/java/Makefile @@ -8,9 +8,13 @@ all: @echo "Building java application..." @${MVN} package -q -Dmaven.test.skip -Dcmake=false -Dmaven.wagon.http.retryHandler.count=15 +test-headless: + @echo "Building gui-less java tests..." + @${MVN} test -Dcmake=false -Dmaven.wagon.http.retryHandler.count=15 -Djava.awt.headless=true + test: @echo "Building java tests..." - @${MVN} test --quiet -Dcmake=false -Dmaven.wagon.http.retryHandler.count=15 -Djava.awt.headless=true + @${MVN} test -Dcmake=false -Dmaven.wagon.http.retryHandler.count=15 -Djava.awt.headless=false javadoc: ${MVN} javadoc:javadoc diff --git a/trick_source/java/src/main/java/trick/simcontrol/SimControlApplication.java b/trick_source/java/src/main/java/trick/simcontrol/SimControlApplication.java index 15ebf1ae..11db98db 100644 --- a/trick_source/java/src/main/java/trick/simcontrol/SimControlApplication.java +++ b/trick_source/java/src/main/java/trick/simcontrol/SimControlApplication.java @@ -541,10 +541,23 @@ public class SimControlApplication extends TrickApplication implements PropertyC } } - public void setHostPort(String hostname, int portNum) { + public static void setHostPort(String hostname, int portNum) { host = hostname; port = portNum; } + + // Getting specific values from GUI + public double getExecTime() { return simState.getExecOutTime(); } + + // Passing components as read-only to inheriting classes + protected final JComboBox getRunningSimList() { return runningSimList; } + protected final JXEditorPane getEditorPane() { return statusMsgPane; } + protected final JToggleButton getDataRecButton() { return dataRecButton; } + protected final JToggleButton getRealTimeButton() { return realtimeButton; } + protected final JTextField getSimRunDirField() { return getSimRunDirField(0); } + protected final JTextField getSimRunDirField(int index) { + return (index < simRunDirField.length) ? simRunDirField[index] : null; + } //======================================== diff --git a/trick_source/java/src/test/java/trick/common/ActionInfo.java b/trick_source/java/src/test/java/trick/common/ActionInfo.java new file mode 100644 index 00000000..56104181 --- /dev/null +++ b/trick_source/java/src/test/java/trick/common/ActionInfo.java @@ -0,0 +1,13 @@ +package trick.common; + +public class ActionInfo { + String name; + String text; + String description; + + public ActionInfo(String name, String text, String description) { + this.name = name; + this.text = text; + this.description = description; + } +} \ No newline at end of file diff --git a/trick_source/java/src/test/java/trick/common/ApplicationTest.java b/trick_source/java/src/test/java/trick/common/ApplicationTest.java index 1b3cada5..0a1b2ded 100644 --- a/trick_source/java/src/test/java/trick/common/ApplicationTest.java +++ b/trick_source/java/src/test/java/trick/common/ApplicationTest.java @@ -1,6 +1,17 @@ package trick.common; -public class ApplicationTest { +import java.util.ArrayList; + +import javax.swing.Action; +import javax.swing.ActionMap; +import org.jdesktop.application.ResourceMap; + +import trick.common.ActionInfo; + +public abstract class ApplicationTest { + protected ArrayList coreActionInfo, supportActionInfo, miscActionInfo; + protected ActionMap actionContext; + protected ResourceMap resourceContext; public static String getTrickHome() { String path; @@ -39,4 +50,51 @@ public class ApplicationTest { public static void sleep(long ms) { try {Thread.sleep(ms);} catch(Exception ignored) {} } + + private String getActionText(Action action) { + return (String)action.getValue(Action.NAME); + } + + private String getActionShortDescription(Action action) { + return (String)action.getValue(Action.SHORT_DESCRIPTION); + } + + private Action getActionFromKey(String actionKey) { + String errMsg = String.format("No ActionMap set. Action '%s' cannot be searched for.\n", actionKey); + // assumeNotNull(errMsg, actionContext); + return actionContext.get(actionKey); + } + + protected void setupExpectedActionInfo() { + coreActionInfo = new ArrayList(); + supportActionInfo = new ArrayList(); + miscActionInfo = new ArrayList(); + + getCoreActionInfo(); + getSupportActionInfo(); + getMiscActionInfo(); + } + + // protected void verifyActionInfo(ActionInfo aInfo) { + // Action action = getActionFromKey(aInfo.name); + // assumeNotNull(String.format("ActionMap.get(\"%s\") = null", aInfo.name), action); + + // String actualText = getActionText(action); + // String actualDesc = getActionShortDescription(action); + + // assertEquals(aInfo.text, actualText); + // assertEquals(aInfo.description, actualDesc); + // } + + // protected void verifyResourceInfo(String key, String expectedStr) { + // String resourceText, errMsg = String.format("No ResourceMap set. Resource '%s' cannot be searched for.\n", key); + // assumeNotNull(errMsg, resourceContext); + + // resourceText = resourceContext.getString(key); + // assertEquals(expectedStr, resourceText); + // } + + protected abstract void getCoreActionInfo(); + protected abstract void getSupportActionInfo(); + protected abstract void getMiscActionInfo(); } diff --git a/trick_source/java/src/test/java/trick/common/GUIController.java b/trick_source/java/src/test/java/trick/common/GUIController.java new file mode 100644 index 00000000..945dba29 --- /dev/null +++ b/trick_source/java/src/test/java/trick/common/GUIController.java @@ -0,0 +1,102 @@ +package trick.common; + +import java.awt.AWTException; +import java.awt.Component; +import java.awt.Point; +import java.awt.Robot; +import java.awt.event.InputEvent; +import java.awt.event.KeyEvent; + +import java.util.Timer; +import java.util.TimerTask; + +public class GUIController extends Robot { + private long depressTime; + + public GUIController() throws AWTException { + super(); + depressTime = 25; + } + + public GUIController(long ms) throws AWTException { + super(); + depressTime = ms; + } + + public void typeString(String entry) { + int keycode; + String upperCaseSpecial = "~!@#$%^&*()_+{}|:\"<>?"; + for (char c : entry.toCharArray()) { + if (Character.isUpperCase(c) || upperCaseSpecial.indexOf(c) >= 0) + keyPress(KeyEvent.VK_SHIFT); + else + keyRelease(KeyEvent.VK_SHIFT); + + switch(c) { + case '\n' : keycode = KeyEvent.VK_ENTER; break; + + default: keycode = KeyEvent.getExtendedKeyCodeForChar(c); break; + } + keyTap(keycode); + sleep(25); + } + + keyRelease(KeyEvent.VK_SHIFT); + } + + public void clearTextField() { + keyPress(KeyEvent.VK_CONTROL); + sleep(depressTime); + + keyTap('A'); + sleep(depressTime); + + keyRelease(KeyEvent.VK_CONTROL); + sleep(depressTime); + + keyTap(KeyEvent.VK_BACK_SPACE); + } + + public void keyTap(int keycode) { + keyPress(keycode); + sleep(depressTime); + keyRelease(keycode); + } + + public void delayedKeyTap(int keycode, long delay) { + Timer timer = new Timer(); + timer.schedule(new TimerTask() { + @Override + public void run() { keyTap(keycode); } + }, delay); + } + + public void delayedTypeString(String entry, long delay) { + Timer timer = new Timer(); + timer.schedule(new TimerTask() { + @Override + public void run() { typeString(entry); } + }, delay); + } + + public void mouseClick(int buttons) { + mousePress(buttons); + sleep(depressTime); + mouseRelease(buttons); + } + + public void mouseClickAt(int buttons, Point pos) { + mouseMove(pos.x, pos.y); + mouseClick(buttons); + } + + public void mouseClickAt(int buttons, Component comp) { + Point pos = comp.getLocationOnScreen(); + pos.translate(comp.getWidth()/2, comp.getHeight()/2); + mouseClickAt(buttons, pos); + } + + private void sleep(long ms) { + try { Thread.sleep(ms); } catch (Exception ignored) { } + } +} \ No newline at end of file diff --git a/trick_source/java/src/test/java/trick/simcontrol/SimControlApplicationTest.java b/trick_source/java/src/test/java/trick/simcontrol/SimControlApplicationTest.java index 1dd9cb42..a6861c84 100644 --- a/trick_source/java/src/test/java/trick/simcontrol/SimControlApplicationTest.java +++ b/trick_source/java/src/test/java/trick/simcontrol/SimControlApplicationTest.java @@ -1,6 +1,7 @@ package trick.simcontrol; - +import java.awt.GraphicsEnvironment; +import java.awt.event.KeyEvent; import java.beans.Transient; import java.io.ByteArrayOutputStream; import java.io.File; @@ -9,6 +10,8 @@ import java.io.IOException; import java.io.PrintStream; import java.util.Arrays; import java.util.Scanner; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import org.jdesktop.application.Application; import org.junit.After; @@ -18,10 +21,12 @@ import org.junit.BeforeClass; import org.junit.Test; import static org.junit.Assert.assertTrue; import static org.junit.Assume.assumeTrue; +import static org.junit.Assume.assumeNotNull; import trick.common.ApplicationTest; import trick.common.SimulationInterface; import trick.common.utils.VariableServerConnection; +import trick.common.ActionInfo; /** * @@ -39,7 +44,7 @@ public class SimControlApplicationTest extends ApplicationTest { private final int MODE_FREEZE = 1, MODE_RUN = 5; - private static HeadlessSimControlApplication simControl; + private static SimControlApplication simControl; private static VariableServerConnection varserv; private static Process simProc; private static String host; @@ -48,6 +53,7 @@ public class SimControlApplicationTest extends ApplicationTest { @BeforeClass public static void setUpBeforeClass() { String fullDir = getTrickHome() + SIM_DIR; + simControl = null; SimulationInterface.cleanSim(fullDir); SimulationInterface.compileSim(fullDir); @@ -77,16 +83,373 @@ public class SimControlApplicationTest extends ApplicationTest { @AfterClass public static void tearDownAfterClass() { - // if(simControl != null) { - // simControl.freezeSim(); - // simControl.shutdown(); - // } if(simProc != null && simProc.isAlive()) simProc.destroy(); } + @After + public void cleanup() { + simControl = null; + } + + @Override + protected void getCoreActionInfo() { } + + @Override + protected void getSupportActionInfo() { } + + @Override + protected void getMiscActionInfo() { } + @Test public void testStartSim() throws IOException { + if (GraphicsEnvironment.isHeadless()) { + headlessStartSim(); + } else { + guiStartSim(); + } + } + + @Test + public void testFreezeSim() throws IOException { + if (GraphicsEnvironment.isHeadless()) { + headlessFreezeSim(); + } else { + guiFreezeSim(); + } + } + + @Test + public void testConnectionFail() { + // ARRANGE + String expOutput = "Invalid TCP/IP port number \"0\"", output; + + String badH = "localhost"; + int badP = 0; + simControl = new HeadlessSimControlApplication(); + System.setErr(new PrintStream(errContent)); + + // ACT + HeadlessSimControlApplication.setHostPort(badH, badP); + simControl.connect(); + sleep(500); + + // ASSERT + output = errContent.toString(); + assertTrue("Did not recieve the expected error message: \n" + + output, output.indexOf(expOutput) >= 0); + + // CLEAN UP + System.setErr(originalErr); + } + + //--------------------// + // GUI Only Tests // + //--------------------// + + @Test + /** + * Testing that the freezeAtSim() action functions properly. + */ + public void testFreezeAtTimeSimulation() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testFreezeAtTimeSimulation"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + double targetTime = simcontrol.getExecTime() + 3.0; + String statusMsg[], expStatus = "Freeze ON", + expTimeStamp = String.format("%.6f", targetTime); + Matcher line1, line2; + Pattern freezeOffPatt = Pattern.compile("\\|.*\\| Freeze OFF\\.\\n?"), + freezeOnPatt = Pattern.compile("\\|.*\\| Freeze ON\\. Simulation time holding at " + + expTimeStamp + " seconds\\.\\n?"); + + // ACT + simcontrol.controller.delayedTypeString((targetTime + "\n"), 500); + simcontrol.freezeAt(); + + simcontrol.startSim(); + simcontrol.sleep(4000); + + statusMsg = simcontrol.getStatusMessages().split("\n"); + line1 = freezeOffPatt.matcher(statusMsg[0]); + line2 = freezeOnPatt.matcher(statusMsg[1]); + + // ASSERT + assumeTrue("Unexpected number of messages", statusMsg.length == 2); + assumeTrue("Simulation did not start!", line1.find()); + assertTrue("Simulation didn't freeze at " + expTimeStamp + "\n" + statusMsg[1], + line2.find()); + + } + + @Test + /** + * Testing that the freezeInSim() action functions properly. + */ + public void testFreezeInTimeSimulation() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testFreezeInTimeSimulation"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + double targetTime = simcontrol.getExecTime() + 3.0; + String statusMsg[], expStatus = "Freeze ON", + expTimeStamp = String.format("%.6f", targetTime); + Matcher line1, line2; + Pattern freezeOffPatt = Pattern.compile("\\|.*\\| Freeze OFF\\.\\n?"), + freezeOnPatt = Pattern.compile("\\|.*\\| Freeze ON\\. Simulation time holding at " + + expTimeStamp + " seconds\\.\\n?"); + + // ACT + simcontrol.controller.delayedTypeString("3.0\n", 500); + simcontrol.freezeIn(); + + simcontrol.startSim(); + simcontrol.sleep(4000); + + statusMsg = simcontrol.getStatusMessages().split("\n"); + line1 = freezeOffPatt.matcher(statusMsg[0]); + line2 = freezeOnPatt.matcher(statusMsg[1]); + + // ASSERT + assumeTrue("Unexpected number of messages", statusMsg.length == 2); + assumeTrue("Simulation did not start!", line1.find()); + assertTrue("Simulation didn't freeze at " + expTimeStamp + "\n" + statusMsg[1], + line2.find()); + + } + + @Test + /** + * Testing that the startSim() action functions properly after the + * freezeSim() action. + */ + public void testRestartSimulation() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testRestartSimulation"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + String statusMsg; + String[] statusLines; + Matcher line1, line2, line3; + Pattern freezeOffPatt = Pattern.compile("\\|.*\\| Freeze OFF\\.\\n?"), + freezeOnPatt = Pattern.compile("\\|.*\\| Freeze ON\\. Simulation time holding at \\d+\\.\\d+ seconds\\.\\n?"); + + int counter = 0; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + // ACT + simcontrol.startSim(); + sleep(1000); + + simcontrol.freezeSim(); + sleep(1000); + + simcontrol.startSim(); + + do { + counter++; + sleep(500); + statusMsg = simcontrol.getStatusMessages(); + statusLines = statusMsg.split("\n"); + } while(statusLines.length < 3 && counter < 6); + + assumeTrue("Status Message Pane does not have the expected number of entries!", statusLines.length >= 3); + line1 = freezeOffPatt.matcher(statusLines[0]); + line2 = freezeOnPatt.matcher(statusLines[1]); + line3 = freezeOffPatt.matcher(statusLines[2]); + + simcontrol.freezeSim(); + + // ASSERT + assertTrue( "Simulation didn't start correctly:\n" + statusLines[0], line1.find()); + assertTrue("Simulation didn't freeze correctly:\n" + statusLines[1], line2.find()); + assertTrue("Simulation didn't resume correctly:\n" + statusLines[2], line3.find()); + } + + @Test + /** + * Testing that the dumpChkpntASCII() action functions properly. + */ + public void testDumpCheckpointSimulation() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testDumpCheckpointSimulation"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + String expMsg = "Dumped ASCII Checkpoint ", actualMsg, errMsg, + fileName, filePath = getTrickHome() + SIM_DIR + "/RUN_test/"; + File checkpointFile; + int nameIndex; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + // ACT + simcontrol.controller.delayedKeyTap(KeyEvent.VK_ENTER, 500); + simcontrol.controller.delayedKeyTap(KeyEvent.VK_ENTER, 750); + simcontrol.dumpChkpntASCII(); + sleep(500); + + actualMsg = simcontrol.getStatusMessages(); + nameIndex = actualMsg.indexOf(expMsg); + assumeTrue("Dumped Checkpoint Message Not Found", nameIndex >= 0); + + nameIndex += expMsg.length(); + fileName = actualMsg.substring(nameIndex, actualMsg.length() - 2); + checkpointFile = new File(filePath + fileName ); + + // ASSERT + errMsg = String.format("'%s' Checkpoint File Not Found At '%s'\n", fileName, filePath); + assumeNotNull(errMsg, checkpointFile); + assertTrue(errMsg, checkpointFile.exists()); + + // CLEANUP + checkpointFile.delete(); + } + + @Test + /** + * Testing that the loadChkpnt() action functions properly. + */ + public void testLoadCheckpointSimulation() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testLoadCheckpointSimulation"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + String actualMsgs[], fileName = "TESTING_CHECKPOINT_LOAD", + expMsgs[] = {"Load checkpoint file " + getTrickHome() + SIM_DIR + "/RUN_test/TESTING_CHECKPOINT_LOAD.", + "Finished loading checkpoint file. Calling restart jobs.", + "|8.700000| restart variable server message port = " + port}; + + int counter = 0; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + // ACT + simcontrol.controller.delayedTypeString(fileName + "\n", 500); + simcontrol.loadChkpnt(); + sleep(5000); + actualMsgs = simcontrol.getStatusMessages().split("\n"); + + assumeTrue("Unexpected Status Messages:\n" + Arrays.toString(actualMsgs), actualMsgs.length >= 3); + + // ASSERT + assertTrue("Unexpected Status Message:\n" + actualMsgs[0], actualMsgs[0].endsWith(expMsgs[0])); + assertTrue("Unexpected Status Message:\n" + actualMsgs[1], actualMsgs[1].endsWith(expMsgs[1])); + assertTrue("Unexpected Status Message:\n" + actualMsgs[2], actualMsgs[2].endsWith(expMsgs[2])); + + + } + + @Test + /** + * Testing that data recording toggles off and on correctly. + */ + public void testDataRecordingToggle() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testDataRecordingToggle"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + final boolean expectedOrder[] = {true, false, true}; + boolean actualOrder[] = new boolean[3]; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + // ACT + for(int i = 0; i < actualOrder.length; i++) { + actualOrder[i] = simcontrol.isDataRecOn(); + simcontrol.toggleDataRecButton(); + sleep(1000); + } + + // ASSERT + assertTrue("Data Recording was not ON at the start of the Sim", + expectedOrder[0] == actualOrder[0]); + assertTrue("Data Recording didn't toggle OFF correctly", + expectedOrder[1] == actualOrder[1]); + assertTrue("Data Recording didn't toggle back ON correctly", + expectedOrder[2] == actualOrder[2]); + } + + @Test + /** + * Testing that data recording toggles off and on correctly. + */ + public void testRealTimeToggle() { + if (GraphicsEnvironment.isHeadless()) { + String testName = "testRealTimeToggle"; + System.out.println("Testing Headlessly. Skipping '" + testName + "'"); + return; + } + + // ARRANGE + final boolean expectedOrder[] = {true, false, true}; + boolean actualOrder[] = new boolean[3]; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication simcontrol = (WaitForSimControlApplication) simControl; + + // ACT + for(int i = 0; i < actualOrder.length; i++) { + actualOrder[i] = simcontrol.isRealTimeOn(); + simcontrol.toggleRealTimeButton(); + sleep(1000); + } + + // ASSERT + assertTrue("Real Time was not ON at the start of the Sim", + expectedOrder[0] == actualOrder[0]); + assertTrue("Real Time didn't toggle OFF correctly", + expectedOrder[1] == actualOrder[1]); + assertTrue("Real Time didn't toggle back ON correctly", + expectedOrder[2] == actualOrder[2]); + } + + // Hybrid Test helper methods + + private void headlessStartSim() throws IOException { // ARRANGE String out; int mode = 1, count = 0; @@ -101,6 +464,7 @@ public class SimControlApplicationTest extends ApplicationTest { varserv.put("trick.var_send_once(\"trick_sys.sched.mode\")"); mode = Integer.parseInt(varserv.get().split("\t")[1]); assumeTrue("Sim Mode was not MODE_FREEZE at test start", mode == MODE_FREEZE); + simControl.startSim(); do { count ++; @@ -115,12 +479,41 @@ public class SimControlApplicationTest extends ApplicationTest { varserv.put("trick.exec_freeze()\n"); } - @Test - public void testFreezeSim() throws IOException { + private void guiStartSim() throws IOException { + // ARRANGE + String statusMsg, expStatus = "Freeze OFF"; + int counter = 0; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication guiControl = (WaitForSimControlApplication) simControl; + + // ACT + varserv.put("trick.var_send_once(\"trick_sys.sched.mode\")"); + int mode = Integer.parseInt(varserv.get().split("\t")[1]); + assumeTrue("Sim Mode was not MODE_FREEZE at test start", mode == MODE_FREEZE); + + guiControl.clearStatusMsgs(); + guiControl.startSim(); + + do { + counter++; + sleep(500); + statusMsg = guiControl.getStatusMessages(); + } while(statusMsg.isEmpty() && counter < 5); + + guiControl.freezeSim(); + + // ASSERT + assertTrue("Simulation did not start!\n" + statusMsg, statusMsg.indexOf(expStatus) != -1); + } + + private void headlessFreezeSim() throws IOException { // ARRANGE String out; int mode = 1, count = 0; - + simControl = new HeadlessSimControlApplication(host, port); sleep(1000); @@ -145,28 +538,49 @@ public class SimControlApplicationTest extends ApplicationTest { // ASSERT assertTrue("Sim Mode is not MODE_FREEZE (1)\nMODE_ID=" + mode, mode == MODE_FREEZE); } - - @Test - public void testConnectionFail() { - // ARRANGE - String expOutput = "Invalid TCP/IP port number \"0\"", output; - String badH = "localhost"; - int badP = 0; - simControl = new HeadlessSimControlApplication(); - System.setErr(new PrintStream(errContent)); + private void guiFreezeSim() throws IOException { + // ARRANGE + String statusMsg, expStatus = "Freeze ON"; + int counter = 0; + + startApplication(true); + assumeTrue("Sim Control Panel didn't start...", simControl != null); + + WaitForSimControlApplication guiControl = (WaitForSimControlApplication) simControl; // ACT - simControl.setHostPort(badH, badP); - simControl.connect(); - sleep(500); + guiControl.startSim(); + guiControl.freezeSim(); + + do { + counter++; + sleep(500); + statusMsg = guiControl.getStatusMessages(); + } while(statusMsg.indexOf(expStatus) < 0 && counter < 5); // ASSERT - output = errContent.toString(); - assertTrue("Did not recieve the expected error message: \n" - + output, output.indexOf(expOutput) >= 0); + assertTrue("Simulation did not freeze!\n" + statusMsg, statusMsg.indexOf(expStatus) != -1); + } - // CLEAN UP - System.setErr(originalErr); + private static void startApplication(boolean startConnected) { + if(simControl == null) { + if(startConnected) // Launch Testing SimControlPanel with the provided connection info + WaitForSimControlApplication.launchAndWait(WaitForSimControlApplication.class, host, port); + else // Launch Testing SimControlPanel + WaitForSimControlApplication.launchAndWait(WaitForSimControlApplication.class); + + handleAppSetup(); + } else { + System.err.println("SimControlApplication is already Running..."); + } + } + + private static void handleAppSetup() { + // Set up the required variables for testing + simControl = Application.getInstance(WaitForSimControlApplication.class); + + // Ensure that everything got set up correctly. + assumeTrue("SimControlApplicationTest is not ready yet!", simControl.isReady()); } } \ No newline at end of file diff --git a/trick_source/java/src/test/java/trick/simcontrol/WaitForSimControlApplication.java b/trick_source/java/src/test/java/trick/simcontrol/WaitForSimControlApplication.java new file mode 100644 index 00000000..8980eb2f --- /dev/null +++ b/trick_source/java/src/test/java/trick/simcontrol/WaitForSimControlApplication.java @@ -0,0 +1,138 @@ +package trick.simcontrol; + +import javax.swing.JFrame; +import javax.swing.JComboBox; +import javax.swing.JEditorPane; +import javax.swing.JTextField; +import javax.swing.JToggleButton; +import javax.swing.text.Document; + +import java.awt.AWTException; +import java.awt.Component; +import java.awt.Point; +import java.awt.Rectangle; +import java.awt.Robot; +import java.awt.event.InputEvent; +import java.awt.event.KeyEvent; +import java.awt.event.WindowEvent; + +import org.jdesktop.application.Application; +import org.jdesktop.swingx.JXEditorPane; + +import trick.common.GUIController; +import trick.simcontrol.SimControlApplication; + + +public class WaitForSimControlApplication extends SimControlApplication { + static Object lock = new Object(); + + boolean isEnded; + public GUIController controller; + + public WaitForSimControlApplication() throws AWTException{ + super(); + controller = new GUIController(); + // controller.setAutoDelay(250); + } + + public void sleep(long ms) { + try { Thread.sleep(ms); } catch (Exception ignored) { } + } + + @Override + protected void end() { + isEnded = true; + } + + @Override + protected void ready() { + super.ready(); + synchronized(lock) { + lock.notifyAll(); + } + } + + public static void launchAndWait(Class applicationClass, String host, int port) { + setHostPort(host, port); + launchAndWait(applicationClass); + } + + /** + * Launch the specified subclsas of SimControlApplication and block + * (wait) until it's startup() method has run. + */ + public static void launchAndWait(Class applicationClass) { + synchronized(lock) { + Application.launch(applicationClass, new String[]{}); + while(true) { + try { + lock.wait(); + } + catch (InterruptedException e) { + System.err.println("launchAndWait interrupted!"); + break; + } + Application app = Application.getInstance(WaitForSimControlApplication.class); + if (app instanceof WaitForSimControlApplication) { + if (((WaitForSimControlApplication)app).isReady()) { + break; + } + } + } + } + } + + //======================================== + // Robot Methods + //======================================== + public void editRunningSimList(String socketInfo) { + getRunningSimList().setSelectedItem(socketInfo); + } + + public void toggleDataRecButton() { + JToggleButton button = getDataRecButton(); + selectComponent(button); + } + + public void toggleRealTimeButton() { + JToggleButton button = getRealTimeButton(); + selectComponent(button); + } + + private void selectAndClearField(Component field) { + selectComponent(field); + controller.clearTextField(); + controller.waitForIdle(); + } + + private void selectComponent(Component comp) { + controller.mouseClickAt(InputEvent.BUTTON1_DOWN_MASK, comp); + controller.waitForIdle(); + } + + //======================================== + // Getter Methods + //======================================== + public String getRunningSimInfo() { + JTextField runDir = getSimRunDirField(); + if (runDir == null) { + return ""; + } + return runDir.getText(); + } + + public String getStatusMessages() { + JXEditorPane status = getEditorPane(); + String msg = ""; + try { + Document doc = status.getDocument(); + msg = doc.getText(0, doc.getLength()); + } catch (Exception e) { + msg = e.getMessage(); + } + return msg; + } + + public boolean isDataRecOn() { return getDataRecButton().isSelected(); } + public boolean isRealTimeOn() { return getRealTimeButton().isSelected(); } +} \ No newline at end of file