// This file has been automatically generated. Manual changes will be overridden.

mod tests{
	use crate::ebi_framework::{
		ebi_command::EbiCommand,
		ebi_input::{self, EbiInput, read_as_object_with_file_handler, TEST_INPUT_TYPE_STRING, TEST_INPUT_TYPE_USIZE, TEST_INPUT_TYPE_FRACTION}
	};
	use ebi_objects::ebi_activity_key::TestActivityKey;
	use crate::multiple_reader::MultipleReader;
	use ntest::timeout;
	use std::fs::File;


	// ==== group Ebi ====


	// ==== group ana ====


	// ==== command all ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/empty.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_all_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ALL,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command comp ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/oc-log.ocel"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/simple_log_markovian_abstraction.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_comp_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COMPLETENESS,
			&[
				"trait event log#./testfiles/svn60.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COMPLETENESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command cov ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/aa.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/ba.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/bb.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/empty.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/empty.xes",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_cov_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_COVERAGE,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_COVERAGE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command dfgedi ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE,
			&[
				"object directly follows graph#./testfiles/aa-ab-ba.dfg",
				"object directly follows graph#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE,
			&[
				"object directly follows graph#./testfiles/aa-ab-ba.dfg",
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE,
			&[
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"object directly follows graph#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE,
			&[
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command dfgedi-nf ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_nf_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES,
			&[
				"object directly follows graph#./testfiles/aa-ab-ba.dfg",
				"object directly follows graph#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_nf_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES,
			&[
				"object directly follows graph#./testfiles/aa-ab-ba.dfg",
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_nf_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES,
			&[
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"object directly follows graph#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_dfgedi_nf_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES,
			&[
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_DIRECTLY_FOLLOWS_EDGE_DIFFERENCE_NO_FREQUENCIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command en ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_en_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_ENTROPY,
			&[
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_ENTROPY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command med ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_med_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MEDOID,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command minprob ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-aa-bb.slpn",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-b-double.xes",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-b.csv",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-b.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-b.xes",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-b.xes.gz",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/a-b_multiple_separators.csv",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-aaa-bb.slpn",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_8() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba.sdfa",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_10() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba.snfa",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba_ali.slpn",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba_occ-f64.slpn",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba_occ.slpn",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa-ab-ba_uni.slpn",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_minprob_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MINPROB,
			&[
				"trait stochastic deterministic semantics#./testfiles/aa.slang",
				"fraction 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("stochastic deterministic semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MINPROB {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command mode ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/empty.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mode_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MODE,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MODE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command mostlikely ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/empty.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/empty.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_mostlikely_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_MOSTLIKELY,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_MOSTLIKELY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command var ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/empty.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_ana_var_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_VARIETY,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse::EBI_ANALYSE_VARIETY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group anans ====


	// ==== command act ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/aa-ab-ba.ali"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ali").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_act_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES,
			&[
				"trait activities#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ACTIVITIES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command at ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic non-deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic non-deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba_unreachable_final_state.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_unreachable_final_state.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_at_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_ANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command bnd ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic non-deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic non-deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba_unreachable_final_state.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_unreachable_final_state.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/empty.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/empty.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/empty.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_bnd_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_BOUNDED,
			&[
				"object deterministic finite automaton#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_BOUNDED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command clus ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/aa-ab-ba.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/aa.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/ba.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/bb.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_clus_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_CLUSTER,
			&[
				"trait finite language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_CLUSTER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command et ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/aa.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/all_operators.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/all_operators.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/empty.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/empty_2.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_2.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c))-uniform.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c))-uniform.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/tree.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/tree.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_et_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES,
			&[
				"object process tree#./testfiles/valid nested.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/valid nested.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EMPTY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command exs ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_exs_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_EXECUTIONS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command inft ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic non-deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic non-deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba_unreachable_final_state.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_unreachable_final_state.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_inft_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES,
			&[
				"object deterministic finite automaton#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_INFINITELY_MANY_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command med ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/aa-ab-ba.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/aa.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/ba.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/bb.lang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_med_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_MEDOID,
			&[
				"trait finite language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_MEDOID {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command to ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"object executions#./testfiles/a-b.exs"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.exs").unwrap());
		let object0 = read_as_object_with_file_handler(&"executions".parse().unwrap(), &mut reader, None, 0, &mut None, "executions".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "executions".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"object executions#./testfiles/svn60.lpn.exs"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.lpn.exs").unwrap());
		let object0 = read_as_object_with_file_handler(&"executions".parse().unwrap(), &mut reader, None, 0, &mut None, "executions".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "executions".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/oc-log.ocel"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/simple_log_markovian_abstraction.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_anans_to_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED,
			&[
				"trait event log with event attributes#./testfiles/svn60.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with event attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_analyse_non_stochastic::EBI_ANALYSE_NON_STOCHASTIC_TIMESTAMPS_ORDERED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group asso ====


	// ==== command att ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_0() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_1() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_2() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_3() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_4() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_5() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_6() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_att_test_7() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}


	// ==== command atts ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_0() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_1() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_2() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ASSOCIATION_ATTRIBUTES,
			&[
				"trait event log with trace attributes#./testfiles/empty.xes",
				"usize 10"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ASSOCIATION_ATTRIBUTES,
			&[
				"trait event log with trace attributes#./testfiles/fig_a.xes",
				"usize 10"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_5() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ASSOCIATION_ATTRIBUTES,
			&[
				"trait event log with trace attributes#./testfiles/simple_log_markovian_abstraction.xes",
				"usize 10"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_asso_atts_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_ASSOCIATION_ATTRIBUTES,
			&[
				"trait event log with trace attributes#./testfiles/svn60.xes",
				"usize 10"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_association::EBI_ASSOCIATION_ATTRIBUTES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group conf ====


	// ==== command cssc ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_uni.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command cssc-sample ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_cssc_sample_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_CHI_SQUARED_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_CHI_SQUARED_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command emsc ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object1 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic partially ordered language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"object finite stochastic partially ordered language#./testfiles/model.sbpmn.spolang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/model.sbpmn.spolang").unwrap());
		let object1 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic partially ordered language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS,
			&[
				"object finite stochastic partially ordered language#./testfiles/flower.sbpmn.spolang",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_16() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_test_17() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn.spolang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic partially ordered language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic partially ordered language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic partially ordered language".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS {
			assert!(((execute)(inputs, None)).is_err())
		}
	}


	// ==== command emsc-sample ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_emsc_sample_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_EARTH_MOVERS_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command er ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_uni.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_er_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_ENTROPIC_RELEVANCE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_ENTROPIC_RELEVANCE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command gp ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b-double.xes",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "extensible event stream".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_1() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "comma-separated values".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "extensible event stream".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes.gz",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "compressed event log".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_5() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "comma-separated values".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.dfg",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.sdfa",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_9() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/abc-acb-aaabc.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/ba-aa-ab.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_14() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_15() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a-sample.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gp_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_PRECISION,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command gr ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b-double.xes",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "extensible event stream".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.csv",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "comma-separated values".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "extensible event stream".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes.gz",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "compressed event log".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/a-b_multiple_separators.csv",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "comma-separated values".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.dfg",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.sdfa",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/aa.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/abc-acb-aaabc.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/ba-aa-ab.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/ba.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/bb.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a-sample.slang",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "finite stochastic language".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_gr_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_GAIN_RECALL,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"fraction 0"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let input2 = EbiInput::Fraction("0".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_GAIN_RECALL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command hsc ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_uni.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command hsc-sample ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_hsc_sample_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_HELLINGER_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_HELLINGER_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command jssc ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty.xes"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command jssc-sample ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_14() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_15() {
		// this test has been indicated as to be expected to fail
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_jssc_sample_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_JSSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_JSSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command ma ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-aaa-bb.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.dfg",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.sdfa",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.sdfm",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic directly follows model".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.snfa",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic non-deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic non-deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_ali.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_occ.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_uni.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/bpic12-a.xes.gz-dfg.dfg",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/bpic12-a.xes.gz-dfg.sdfm",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.sdfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic directly follows model".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/empty.sdfa",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/empty.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/empty_net.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_net.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/fig_c.sdfa",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_c.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_ma_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_MARKOVIAN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn",
				"object stochastic labelled Petri net#./testfiles/simple_markovian_abstraction.slpn",
				"usize 1",
				"string cssc"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_markovian_abstraction.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::String("cssc".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_MARKOVIAN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command uemsc ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa-ab-ba_uni.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait queriable stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command uemsc-sample ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conf_uemsc_sample_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_UEMSC_SAMPLE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance::EBI_CONFORMANCE_UEMSC_SAMPLE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group confns ====


	// ==== command ali ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_ali_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command eep ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_0() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_1() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_2() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION,
			&[
				"object stochastic language of alignments#./testfiles/aa-ab-ba.sali",
				"trait semantics#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_4() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_5() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_6() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION,
			&[
				"object stochastic language of alignments#./testfiles/aa-ab-ba.sali",
				"trait semantics#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_8() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_9() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_10() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_11() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_12() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_13() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_16() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_eep_test_17() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_ESCAPING_EDGES_PRECISION {
			assert!(((execute)(inputs, None)).is_err())
		}
	}


	// ==== command setali ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_setali_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS,
			&[
				"trait finite language#./testfiles/a-b-double.xes",
				"trait semantics#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("semantics".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_SET_ALIGNMENTS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command tfit ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_confns_tfit_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONFORMANCE_NON_STOCHASTIC_TRACE_FITNESS,
			&[
				"object stochastic language of alignments#./testfiles/aa-ab-ba.sali"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sali").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic language of alignments".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic language of alignments".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic language of alignments".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_conformance_non_stochastic::EBI_CONFORMANCE_NON_STOCHASTIC_TRACE_FITNESS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group conv ====


	// ==== command bpmn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_bpmn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_BPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command lang ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/empty.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.lang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/oc-log.ocel"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "object-centric event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "object-centric event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/simple_log_markovian_abstraction.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lang_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LANG,
			&[
				"object finite language#./testfiles/svn60.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command log ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/oc-log.ocel"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "object-centric event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "object-centric event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/simple_log_markovian_abstraction.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_log_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LOG,
			&[
				"object event log#./testfiles/svn60.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command lpn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_lpn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_LPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_LPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command slang ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/empty.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/empty_trace.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slang_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLANG,
			&[
				"object finite stochastic language#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"finite stochastic language".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLANG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command sdfa ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "finite stochastic language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "finite stochastic language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfa_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFA,
			&[
				"object stochastic deterministic finite automaton#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command sdfm ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfm_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFM,
			&[
				"object stochastic directly follows model#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFM {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfm_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFM,
			&[
				"object stochastic directly follows model#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFM {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfm_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFM,
			&[
				"object stochastic directly follows model#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFM {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_sdfm_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SDFM,
			&[
				"object stochastic directly follows model#./testfiles/bpic12-a.xes.gz-dfg.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SDFM {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command slpn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic non-deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic non-deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_uni.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/bpic12-a.xes.gz-dfg.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/empty.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/empty.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/empty_net.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_net.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/fig_c.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_c.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_slpn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SLPN,
			&[
				"object stochastic labelled Petri net#./testfiles/simple_markovian_abstraction.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_markovian_abstraction.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command snfa ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic non-deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic non-deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/aa-ab-ba_uni.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_uni.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/bpic12-a.xes.gz-dfg.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/empty.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/empty.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/empty_net.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_net.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/fig_c.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_c.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_conv_snfa_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_CONVERT_SNFA,
			&[
				"object stochastic labelled Petri net#./testfiles/simple_markovian_abstraction.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_markovian_abstraction.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_convert::EBI_CONVERT_SNFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group disc ====


	// ==== group ali ====


	// ==== command sbpmn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_sbpmn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_BPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_BPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command slpn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_ali_slpn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_ALIGNMENTS_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_ALIGNMENTS_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command dfg ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/a-b-double.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/a-b.csv",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/a-b.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/a-b.xes.gz",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/a-b_multiple_separators.csv",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/empty.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/fig_a.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/oc-log.ocel",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/simple_log_markovian_abstraction.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait event log#./testfiles/svn60.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_dfg_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_DIRECTLY_FOLLOWS,
			&[
				"trait finite stochastic language#./testfiles/aa.slang",
				"fraction 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("1".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_DIRECTLY_FOLLOWS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group occ ====


	// ==== command sbpmn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sbpmn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SBPMN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object business process model and notation#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command slpn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows graph".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "directly follows model".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_slpn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SLPN,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object1 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command sptree ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/aa.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/all_operators.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/all_operators.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.sptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/empty.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/empty_2.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_2.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/seq(a-xor(b-c))-uniform.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c))-uniform.sptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/seq(a-xor(b-c)).ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/seq(a-xor(b-c)).sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).sptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/tree.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/tree.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"object process tree#./testfiles/valid nested.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/valid nested.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"object process tree#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"object process tree#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree markup language".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"object process tree#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"object process tree#./testfiles/aa.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_occ_sptree_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_OCCURRENCE_SPTREE,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"object process tree#./testfiles/all_operators.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.ptree").unwrap());
		let object1 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input1 = EbiInput::Object(object1, "process tree".parse().unwrap());
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_OCCURRENCE_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group rnd ====


	// ==== command sbpmn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sbpmn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command slpn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_slpn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command sptree ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/aa.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/all_operators.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/all_operators.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/empty.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/empty_2.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_2.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c))-uniform.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c))-uniform.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/tree.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/tree.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_rnd_sptree_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_RANDOM_SPTREE,
			&[
				"object process tree#./testfiles/valid nested.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/valid nested.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_RANDOM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group uni ====


	// ==== command sbpmn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sbpmn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SBPMN,
			&[
				"object business process model and notation#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SBPMN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command slpn ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "Petri net markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "Petri net markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_slpn_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SLPN,
			&[
				"object labelled Petri net#./testfiles/aa-ab-ba_occ.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ.slpn").unwrap());
		let object0 = read_as_object_with_file_handler(&"labelled Petri net".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic labelled Petri net".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic labelled Petri net".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SLPN {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command sptree ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/aa.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/all_operators.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/all_operators.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/empty.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/empty_2.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_2.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c))-uniform.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c))-uniform.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/tree.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/tree.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_disc_uni_sptree_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_UNIFORM_SPTREE,
			&[
				"object process tree#./testfiles/valid nested.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/valid nested.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover::EBI_DISCOVER_UNIFORM_SPTREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group dins ====


	// ==== group flw ====


	// ==== command dfa ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/aa-ab-ba.ali"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ali").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_dfa_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA,
			&[
				"trait activities#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command ptree ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/aa-ab-ba.ali"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ali").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_flw_ptree_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE,
			&[
				"trait activities#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("activities".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_FLOWER_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group pfxt ====


	// ==== command dfa ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_dfa_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA,
			&[
				"trait finite language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_DFA {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command ptree ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_pfxt_ptree_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE,
			&[
				"trait finite language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TREE_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command tm ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_tm_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL,
			&[
				"trait finite language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_TRACE_MODEL {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command im ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_im_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER,
			&[
				"trait finite language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command imf ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/aa.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/ba.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/bb.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/empty.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/empty.xes",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_dins_imf_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"fraction 0.2"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Fraction("0.2".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_discover_non_stochastic::EBI_DISCOVER_NON_STOCHASTIC_INDUCTIVE_MINER_INFREQUENT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group fil ====


	// ==== group tr ====


	// ==== command empty ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/empty.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/fig_a.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/simple_log_markovian_abstraction.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_empty_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EMPTY,
			&[
				"object XES event log#./testfiles/svn60.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EMPTY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command len ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/a-b-double.xes",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/a-b.csv",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/a-b.xes",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/a-b.xes.gz",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/a-b_multiple_separators.csv",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/empty.xes",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/fig_a.xes",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/simple_log_markovian_abstraction.xes",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_len_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_LENGTH,
			&[
				"object XES event log#./testfiles/svn60.xes",
				"string <",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("<".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_LENGTH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group event ====


	// ==== command act ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/a-b-double.xes",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/a-b.csv",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/a-b.xes",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/a-b.xes.gz",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/a-b_multiple_separators.csv",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/empty.xes",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/fig_a.xes",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/simple_log_markovian_abstraction.xes",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_fil_tr_event_act_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_FILTER_TRACES_EVENT_ACTIVITY,
			&[
				"object XES event log#./testfiles/svn60.xes",
				"string any",
				"string some string"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"XES event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::String("any".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let inputs = vec![input0, input1, input2];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_filter::EBI_FILTER_TRACES_EVENT_ACTIVITY {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group it ====


	// ==== group docs ====










	// ==== command info ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object business process model and notation#./testfiles/flower.bpmn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.bpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "business process model and notation".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object business process model and notation#./testfiles/model-lanes.bpmn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/model-lanes.bpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "business process model and notation".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object business process model and notation#./testfiles/model.bpmn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/model.bpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "business process model and notation".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba_unreachable_final_state.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_unreachable_final_state.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object deterministic finite automaton#./testfiles/empty.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows graph#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows model#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows model#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows model#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows model#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object directly follows model#./testfiles/empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object event log#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object event log#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object event log#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object event log#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_info_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_INFO,
			&[
				"object event log#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_info::EBI_INFO {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group prob ====


	// ==== command log ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/a-b-double.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/a-b.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/a-b.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/a-b.xes"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/aa-ab-ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/aa-ab-ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/aa.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/aa.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/abc-acb-aaabc.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/ba-aa-ab.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/ba.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/ba.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/bb.lang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.lang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/bb.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_prob_log_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_PROBABILITY_LOG,
			&[
				"trait queriable stochastic language#./testfiles/a-aa-bb.slpn",
				"trait finite language#./testfiles/bpic12-a-sample.slang"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("queriable stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_probability::EBI_PROBABILITY_LOG {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}




	// ==== group red ====


	// ==== command ptr ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/aa.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/all_operators.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/all_operators.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/all_operators.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/empty.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/empty_2.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_2.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c))-uniform.sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c))-uniform.sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/seq(a-xor(b-c)).sptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/seq(a-xor(b-c)).sptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/tree.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/tree.ptree").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_red_ptr_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_REDUCE_PROCESS_TREE,
			&[
				"object process tree#./testfiles/valid nested.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/valid nested.ptml").unwrap());
		let object0 = read_as_object_with_file_handler(&"process tree".parse().unwrap(), &mut reader, None, 0, &mut None, "process tree markup language".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "process tree markup language".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_reduce::EBI_REDUCE_PROCESS_TREE {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group sam ====


	// ==== command folds ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/a-b-double.xes",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/a-b.csv",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/a-b.xes",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/a-b.xes.gz",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/a-b_multiple_separators.csv",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/empty.xes",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/fig_a.xes",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/oc-log.ocel",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "object-centric event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "object-centric event log".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/simple_log_markovian_abstraction.xes",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_folds_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_FOLDS,
			&[
				"object event log#./testfiles/svn60.xes",
				"usize 1",
				"usize 0",
				"usize 0"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let input2 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Usize(0, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_FOLDS {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command potr ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_potr_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_PARTIALLY_ORDERED_TRACES,
			&[
				"object stochastic business process model and notation#./testfiles/flower.sbpmn",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.sbpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic business process model and notation".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_PARTIALLY_ORDERED_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_potr_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_PARTIALLY_ORDERED_TRACES,
			&[
				"object stochastic business process model and notation#./testfiles/model.sbpmn",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/model.sbpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"stochastic business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "stochastic business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "stochastic business process model and notation".parse().unwrap());
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_PARTIALLY_ORDERED_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command tra ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_sam_tra_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_SAMPLE_TRACES,
			&[
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 1"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::Usize(1, &TEST_INPUT_TYPE_USIZE);
		let inputs = vec![input0, input1];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_sample::EBI_SAMPLE_TRACES {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== group tst ====


	// ==== command btst ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.csv",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b.xes.gz",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/a-b_multiple_separators.csv",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa-ab-ba.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/aa.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/abc-acb-aaabc.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/abc-acb-aaabc.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/acb-abc-ad-aded-adeded-adededed.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/acb-abc-ad-aded-adeded-adededed.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba-aa-ab.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba-aa-ab.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/ba.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/ba.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bb.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bb.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/bpic12-a-sample.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a-sample.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_14() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_15() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/empty_trace.slang",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty_trace.slang").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_btst_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_TEST_BOOTSTRAP,
			&[
				"trait finite stochastic language#./testfiles/a-b-double.xes",
				"trait finite stochastic language#./testfiles/fig_a.xes",
				"usize 10",
				"fraction 0.05"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object1, file_handler1) = ebi_input::read_as_trait(&("finite stochastic language".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input1 = EbiInput::Trait(object1, file_handler1);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_BOOTSTRAP {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command lcat ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_0() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_1() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_2() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_3() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_4() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/fig_a.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_5() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/oc-log.ocel").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_6() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/simple_log_markovian_abstraction.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_tst_lcat_test_7() {
		// this test has been indicated as to be expected to fail
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/svn60.xes").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("event log with trace attributes".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let input1 = EbiInput::String("some string".to_string(), &TEST_INPUT_TYPE_STRING);
		let input2 = EbiInput::Usize(10, &TEST_INPUT_TYPE_USIZE);
		let input3 = EbiInput::Fraction("0.05".parse().unwrap(), &TEST_INPUT_TYPE_FRACTION);
		let inputs = vec![input0, input1, input2, input3];

		if let EbiCommand::Command{execute, ..} = crate::ebi_commands::ebi_command_test::EBI_TEST_LOG_ATTRIBUTE {
			assert!(((execute)(inputs, None)).is_err())
		}
	}



	// ==== group vis ====


	// ==== command graph ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/a-aa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-aa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/a-b-flower.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-flower.ptree").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/a.pnml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a.pnml").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-aaa-bb.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-aaa-bb.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.lpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.lpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.ptml"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptml").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.ptree"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.ptree").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.sdfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.sdfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.sdfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba.snfa"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.snfa").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba_ali.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_ali.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_graph_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_GRAPH,
			&[
				"trait graphable#./testfiles/aa-ab-ba_occ-f64.slpn"			
			]
		),
		*/
		
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_occ-f64.slpn").unwrap());
		let (object0, file_handler0) = ebi_input::read_as_trait(&("graphable".parse().unwrap()), &mut reader, None, 0).unwrap();
		let input0 = EbiInput::Trait(object0, file_handler0);
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_GRAPH {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}


	// ==== command txt ====
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_0() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object business process model and notation#./testfiles/flower.bpmn"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/flower.bpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "business process model and notation".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_1() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object business process model and notation#./testfiles/model-lanes.bpmn"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/model-lanes.bpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "business process model and notation".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_2() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object business process model and notation#./testfiles/model.bpmn"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/model.bpmn").unwrap());
		let object0 = read_as_object_with_file_handler(&"business process model and notation".parse().unwrap(), &mut reader, None, 0, &mut None, "business process model and notation".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "business process model and notation".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_3() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba.dfa"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_4() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object deterministic finite automaton#./testfiles/aa-ab-ba_unreachable_final_state.dfa"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba_unreachable_final_state.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_5() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object deterministic finite automaton#./testfiles/empty.dfa"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfa").unwrap());
		let object0 = read_as_object_with_file_handler(&"deterministic finite automaton".parse().unwrap(), &mut reader, None, 0, &mut None, "deterministic finite automaton".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "deterministic finite automaton".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_6() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows graph#./testfiles/aa-ab-ba.dfg"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_7() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows graph#./testfiles/bpic12-a.xes.gz-dfg.dfg"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/bpic12-a.xes.gz-dfg.dfg").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows graph".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows graph".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows graph".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_8() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows model#./testfiles/a-b_star.dfm"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_9() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows model#./testfiles/a-b_star_empty.dfm"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_10() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows model#./testfiles/a-b_star_empty_trace.dfm"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_star_empty_trace.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_11() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows model#./testfiles/aa-ab-ba.slang.dfm"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/aa-ab-ba.slang.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_12() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object directly follows model#./testfiles/empty.dfm"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/empty.dfm").unwrap());
		let object0 = read_as_object_with_file_handler(&"directly follows model".parse().unwrap(), &mut reader, None, 0, &mut None, "directly follows model".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "directly follows model".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_13() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object event log#./testfiles/a-b-double.xes"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b-double.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_14() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object event log#./testfiles/a-b.csv"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_15() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object event log#./testfiles/a-b.xes"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "extensible event stream".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "extensible event stream".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_16() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object event log#./testfiles/a-b.xes.gz"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b.xes.gz").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "compressed event log".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "compressed event log".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
	#[test]
	#[timeout(10000)]
	pub fn ebi_vis_txt_test_17() {
		// to indicate that this test is expected to fail, add the following to src/tests/fallible_test_list.rs:
		/* 
		(
			&EBI_VISUALISE_TEXT,
			&[
				"object event log#./testfiles/a-b_multiple_separators.csv"			
			]
		),
		*/
		if ebi_objects::ebi_arithmetic::is_exact_globally() {
			return;
		}
		let mut reader = MultipleReader::from_file(File::open("./testfiles/a-b_multiple_separators.csv").unwrap());
		let object0 = read_as_object_with_file_handler(&"event log".parse().unwrap(), &mut reader, None, 0, &mut None, "comma-separated values".parse().unwrap()).unwrap();
		let input0 = EbiInput::Object(object0, "comma-separated values".parse().unwrap());
		let inputs = vec![input0];

		if let EbiCommand::Command{execute, output_type, ..} = crate::ebi_commands::ebi_command_visualise::EBI_VISUALISE_TEXT {
			match (execute)(inputs, None) {
				Ok(output) => {
					output.test_activity_key();
					assert_eq!(&output.get_type(), output_type);
				}
				Err(e) => Err(e).unwrap(),
			}
		}
	}
}
