stanhope/

read_ebml.rs

//! *Read a markup file and return a robust Process struct*
//! 
//! All information in the markup file is stored in the Process struct, including information for every step of the Process and the metadata about the Process document's place in the organizations document library.
//! 
//! Structs and Enums are public, but associated fields are private. "Get" and "Set"/"Add" functions exist throughout the implementations such that downstream users can query (or modify) data. Note: changes to process information should occur at the source markup file for it to be re-read, as to retain the truth in the author's source file.

use std::{
	fs::File,
	io::{self, BufRead, BufReader},
	path::Path,
};
use crate::globify_document_number;

//  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄         ▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄ 
// ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌
// ▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀█░█▀▀▀▀ ▐░█▀▀▀▀▀▀▀█░▌▐░▌       ▐░▌▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀█░█▀▀▀▀ 
// ▐░▌               ▐░▌     ▐░▌       ▐░▌▐░▌       ▐░▌▐░▌               ▐░▌     
// ▐░█▄▄▄▄▄▄▄▄▄      ▐░▌     ▐░█▄▄▄▄▄▄▄█░▌▐░▌       ▐░▌▐░▌               ▐░▌     
// ▐░░░░░░░░░░░▌     ▐░▌     ▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░▌               ▐░▌     
//  ▀▀▀▀▀▀▀▀▀█░▌     ▐░▌     ▐░█▀▀▀▀█░█▀▀ ▐░▌       ▐░▌▐░▌               ▐░▌     
//           ▐░▌     ▐░▌     ▐░▌     ▐░▌  ▐░▌       ▐░▌▐░▌               ▐░▌     
//  ▄▄▄▄▄▄▄▄▄█░▌     ▐░▌     ▐░▌      ▐░▌ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄▄▄      ▐░▌     
// ▐░░░░░░░░░░░▌     ▐░▌     ▐░▌       ▐░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌     
//  ▀▀▀▀▀▀▀▀▀▀▀       ▀       ▀         ▀  ▀▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀▀       ▀      
                                                                              
/// **Top-level struct containing all information read from the markup file**
/// 
/// All fields are private, but are accessible with "get" functions, e.g. Process.get_number() returns a reference to the Process's number (&String).
pub struct Process {

	/// Path to the EBML file for this process
	process_file: String,

	/// Document Number, in whatever format makes sense for the organization's document control system
	number: String,

	/// A stack of Revision lines, with an important assumption that the first Revision line represents the current Rev of the document, and the last Revision line represents the first released Rev of the document
	/// * First String: "Rev" text, e.g. "A" for a document's Revision A
	/// * Second String: "What changed?" text, e.g. "New section added to initialize the system prior to start"
	all_revisions: Vec<(String,String)>,
	
	/// Human-readable Title of the process document, hopefully with enough meaning for the team to understand the purpose of the process
	title: String,

	/// Human-readable category of process document, such as "Test Procedure" or "Work Instruction" or "Maintenance Procedure" etc.
	process_type: String,

	/// Human that composed the markup file in its current Revision, i.e. who currently owns the knowledge in this process
	author: String,

	/// Human responsible for being the second set of eyes for this Revision, and who is the gatekeeper to publishing this Revision prior to its use in the field
	reviewer: String,

	/// The thing that this process applies to, i.e. the primary input into the Process, be it tangible or abstract
	subject: String,

	/// File name for an image of the Subject
	subject_image: String,

	/// If this process changes the *Subject* into something else, then that something else is the *Product*
	product: String,

	/// File name for an image of the Product
	product_image: String,

	/// Compiled list of Objective statements found throughout the document when they are achieved
	all_objectives: Vec<(String,String)>,

	/// Compiled list of Out-of-Scope statements found throughout the document when they are achieved
	all_out_of_scopes: Vec<(String,String)>,

	/// Ordered set of all Step-filled sections of the document
	all_sections: Vec<Section>,

	/// Cummulative list of all Resources identified in all Steps
	all_resources: Vec<(Resource,String)>,

	/// Unique list of all resources that need calibration to be used in this process
	all_calibrated_resources: Vec<Resource>,

	/// Cummulative list of all Verifications of Requirements performed in all Steps
	all_verifications: Vec<(Requirement,String)>,

	/// File names for custom templates (CSS) to use that augment the vanilla template
	/// * Company-specific
	/// * Project-specific
	/// * Security environment-specific
	/// * etc.
	all_templates: Vec<String>,

	/// Entire source EBML file for this Process, stored unprocessed in a Vec of Strings (one per line of text)
	full_source: Vec<String>,
}

/// Each Section struct contains all Steps within that document section
pub struct Section {

	/// What the section is named, hopefully descriptive enough that operators know what to expect, and can anticipate operations
	title: String,

	/// Ordered set of all Steps in the section (each Step is rich with Sub-Step information as well)
	all_steps: Vec<Step>,

	/// Relative path from the Process folder to the Process folder where the Section's source exists, empty string unless SECREF is fetched
	relative_path: String,
}

/// Each Step struct contains all Actions, Images, Commands, Resources, Verifications, and Warnings contained in that step
pub struct Step {

	/// Text of the step, analogous to the Title of a Section except at the Step-level
	text: String,

	/// Ordered set of Resources identified in the Step, wherever they are mentioned
	resources: Vec<Resource>,

	/// Ordered set of SubSteps identified, be them sets of Action lines, Commands, Warnings, or Verification events
	/// 
	/// *Note: Resources are not included as SubSteps themselves, although other lines within a Step are*
	all_sub_steps: Vec<SubStep>,
}

/// Each Action struct is a single operation to perform, with an expected result, and an optional Two-Party Verification flag
pub struct Action {

	/// What action the operator is to perform
	perform: String,

	/// What operator is to expect after performing the action
	expect: String,

	/// Is two party verification (TPV) required for this step?
	tpv: bool,
}

/// Each Requirement struct represents a formal "shall" statement whose evidence of verification is produced in a Step of a Process
pub struct Requirement {

	/// Unique ID for the requirement
	id: String,

	/// Full text of the requirement, which includes the word "shall."
	/// 
	/// Example of *good requirement* wording:
	/// 
	/// (When \[SUB/SYSTEM or VARIABLE\] is \[MODE/STATE or VALUE or RANGE\],) \[AGENT\] shall \[BEHAVE\] (within \[TOLERANCE\]). (Note: [CLARIFYING NOTES OR REFERENCES])
	text: String,

	/// Method of verification--how is this requirement to be verified? This is important for processes, because steps to produce evidence of verification should be steps that somehow resemble this verificaiton method.
	method: VerificationMethod,
}

/// Resoures are named things that are needed to perform a Step - without them the Step can't be performed
pub struct Resource { 

	/// Descriptive name of the resource, with enough information to be unambiguous to the operator. For instance, if a specific screwdriver is needed, then "Screwdriver" is probably insufficient as the name of this resource.
	name: String,

	/// Does this resource need to be calibrated to be used in this process?
	calibration: bool,
}

/// A flexible table of arbitrary number of rows and columns, with a caption to describe the table within the process
pub struct Table {

	/// Descriptive string to display alongside the table
	caption: String,

	/// The complete array of table data, with the Vec<Vec<>> representing Row<Col<>>
	/// 
	/// Example: to access the entire header (first) row of the table
	/// > array\[0\]
	/// 
	/// Example: to access the 8th column of the 10th row of the table
	/// > array\[9\]\[7\]
	/// 
	/// All data in the table are stored as strings, as the ultimate destination for these data are in a formatted process document's HTML text. These data are not intended to be numerically manipulated from this Table structure, but rather the assumption is that all of the numerical processing is already complete when these data are read into this structure.
	array: Vec<Vec<String>>,

}

//  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄        ▄  ▄         ▄  ▄▄       ▄▄ 
// ▐░░░░░░░░░░░▌▐░░▌      ▐░▌▐░▌       ▐░▌▐░░▌     ▐░░▌
// ▐░█▀▀▀▀▀▀▀▀▀ ▐░▌░▌     ▐░▌▐░▌       ▐░▌▐░▌░▌   ▐░▐░▌
// ▐░▌          ▐░▌▐░▌    ▐░▌▐░▌       ▐░▌▐░▌▐░▌ ▐░▌▐░▌
// ▐░█▄▄▄▄▄▄▄▄▄ ▐░▌ ▐░▌   ▐░▌▐░▌       ▐░▌▐░▌ ▐░▐░▌ ▐░▌
// ▐░░░░░░░░░░░▌▐░▌  ▐░▌  ▐░▌▐░▌       ▐░▌▐░▌  ▐░▌  ▐░▌
// ▐░█▀▀▀▀▀▀▀▀▀ ▐░▌   ▐░▌ ▐░▌▐░▌       ▐░▌▐░▌   ▀   ▐░▌
// ▐░▌          ▐░▌    ▐░▌▐░▌▐░▌       ▐░▌▐░▌       ▐░▌
// ▐░█▄▄▄▄▄▄▄▄▄ ▐░▌     ▐░▐░▌▐░█▄▄▄▄▄▄▄█░▌▐░▌       ▐░▌
// ▐░░░░░░░░░░░▌▐░▌      ▐░░▌▐░░░░░░░░░░░▌▐░▌       ▐░▌
//  ▀▀▀▀▀▀▀▀▀▀▀  ▀        ▀▀  ▀▀▀▀▀▀▀▀▀▀▀  ▀         ▀ 

/// Each row within a step contributes to a SubStep. Some SubStep types (e.g. ActionSequence) contain information from multiple consecutive rows, whereas others (all others?) contain information from a single markup file row.
pub enum SubStep {

	/// Each objective of the process achieved in this step has a single SubStep of type Objective, simply passing through the string found
	Objective(String),

	/// Each out-of-scope declaration tells what this procedure **doesn't** do, and should tell where in the process library such scope can be found
	OutOfScope(String),

	/// Each element of the ActionSequence vector is the information from a single Action row. Consecutive Action rows in a markup file are bundled into the ActionSequence type of SubStep.
	ActionSequence(Vec<Action>),

	/// Each command row has a String that is verbatim what the operator should type (or paste) into a computer system
	Command(String),

	/// Each Image row has a file name of an image to display on screen (first tuple String) and the caption text to display under the image (second tuple String)
	Image(String,String),

	/// Warning text is something the author wants to force the operator to read prior to proceeding
	Warning(String),

	/// Each Verification row includes sufficient information to form a Verification struct
	Verification(Requirement),

	/// Each Resource row has a String describing a single resource needed to perform the current step, plus a bool field to indicate if it's calibrated equipment
	Resource(Resource),

	/// Vanilla text blocks, to be used sparingly lest the process document get too wordy
	Context(String),

	/// Arbitrary-sized table from comma-separated data
	Table(Table),
}

/// Verification methods include one-of-a-kind systems as well as high-volume production (e.g. Sampling)
pub enum VerificationMethod {

	/// *From NASA:* **Demonstration:** Showing that the use of an end product achieves the individual specified requirement. It is generally a basic confirmation of performance capability, differentiated from testing by the lack of detailed data gathering. Demonstrations can involve the use of physical models or mock-ups; for example, a requirement that all controls shall be reachable by the pilot could be verified by having a pilot perform flight-related tasks in a cockpit mock-up or simulator. A demonstration could also be the actual operation of the end product by highly qualified personnel, such as test pilots, who perform a one-time event that demonstrates a capability to operate at extreme limits of system performance, an operation not normally expected from a representative operational pilot.
	Demonstration,

	/// *From NASA:* **Inspection:** The visual examination of a realized end product. Inspection is generally used to verify physical design features or specific manufacturer identification. For example, if there is a requirement that the safety arming pin has a red flag with the words “Remove Before Flight” stenciled on the flag in black letters, a visual inspection of the arming pin flag can be used to determine if this requirement was met. Inspection can include inspection of drawings, documents, or other records. 
	Inspection,

	/// *From NASA:* **Analysis:** The use of mathematical modeling and analytical techniques to predict the suitability of a design to stakeholder expectations based on calculated data or data derived from lower system structure end product verifications. Analysis is generally used when a prototype; engineering model; or fabricated, assembled, and integrated product is not available. Analysis includes the use of modeling and simulation as analytical tools. A model is a mathematical representation of reality. A simulation is the manipulation of a model. Analysis can include verification by similarity of a heritage product.
	Analysis,

	/// *From NASA:* **Test:** The use of an end product to obtain detailed data needed to verify performance or provide sufficient information to verify performance through further analysis. Testing can be conducted on final end products, breadboards, brassboards, or prototypes. Testing produces data at discrete points for each specified requirement under controlled conditions and is the most resource-intensive verification technique. As the saying goes, “Test as you fly, and fly as you test.” (See Section 5.3.2.5 in the NASA Expanded Guidance for Systems Engineering at [<https://nen.nasa.gov/web/se/doc-repository>])
	Test,

	/// From SEBoK: Technique based on verification of characteristics using samples. The number, tolerance, and other characteristics must be specified to be in agreement with the experience feedback.
	/// 
	/// [<https://sebokwiki.org/wiki/System_Verification#Methods_and_Techniques>]
	Sampling,

}

//  ▄▄▄▄▄▄▄▄▄▄▄  ▄         ▄  ▄▄        ▄  ▄▄▄▄▄▄▄▄▄▄▄ 
// ▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░░▌      ▐░▌▐░░░░░░░░░░░▌
// ▐░█▀▀▀▀▀▀▀▀▀ ▐░▌       ▐░▌▐░▌░▌     ▐░▌▐░█▀▀▀▀▀▀▀▀▀ 
// ▐░▌          ▐░▌       ▐░▌▐░▌▐░▌    ▐░▌▐░▌          
// ▐░█▄▄▄▄▄▄▄▄▄ ▐░▌       ▐░▌▐░▌ ▐░▌   ▐░▌▐░▌          
// ▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░▌  ▐░▌  ▐░▌▐░▌          
// ▐░█▀▀▀▀▀▀▀▀▀ ▐░▌       ▐░▌▐░▌   ▐░▌ ▐░▌▐░▌          
// ▐░▌          ▐░▌       ▐░▌▐░▌    ▐░▌▐░▌▐░▌          
// ▐░▌          ▐░█▄▄▄▄▄▄▄█░▌▐░▌     ▐░▐░▌▐░█▄▄▄▄▄▄▄▄▄ 
// ▐░▌          ▐░░░░░░░░░░░▌▐░▌      ▐░░▌▐░░░░░░░░░░░▌
//  ▀            ▀▀▀▀▀▀▀▀▀▀▀  ▀        ▀▀  ▀▀▀▀▀▀▀▀▀▀▀ 
                                                    
/// Read and interpret an entire Easy Button Markup Language (EBML) file, and return a "Process" struct.
/// 
/// A single Process struct holds all found information about a process, and is itself enough to extract it and produce complex documents.
pub fn read_ebml(file_name:&String) -> Process {

	// empty string input (instead of the name of a file to read) returns a blank Process with no further processing
	if file_name==&String::from("") {
		return Process::new();
	}

	/*
	// function to return all the lines in a file back as a vec of strings
	fn lines_from_file(filename: impl AsRef<Path>) -> io::Result<Vec<String>> {
		BufReader::new(File::open(filename)?).lines().collect()
	}
	*/

	// Instantiate a blank Process to be filled with found information
	let mut new_proc = Process::new();

	// Use the function to pull all the lines out of the markup file
	let lines = lines_from_file(file_name).expect("Could not load lines");
	new_proc.set_process_file(&file_name);
	new_proc.set_full_source(lines.clone());

	// initialize a couple of counters that become the basis of Section numbering and Step numbering below
	let mut sec_cnt = 0;
    let mut stp_cnt = 0;

    // Now loop through all the lines of the input file
    for (ii,line) in lines.iter().enumerate() {

    	// if it's a comment line, then skip this instance of the loop
    	if line.trim().find("//") == Some(0) { continue }

    	// delimit the line by the bar/pipe character
    	let all_parts: Vec<&str> = line.split('|').collect();

    	// in this markup language, the text to the left of the first bar indicates what kind of line it is
    	let first_part: &str = all_parts[0];

    	// Everything to the right of the first bar is important for conditional data extraction (there could also be more pipes)
    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();

    	// "remainder" is everything to the right of the first bar, and a special case is handled here for a blank string (nothing) when there isn't anything to the right of the first bar
    	let remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };
    	
    	// Here's where the actual processing goes. At the PROCESS level, we're looking for process metadata (author, revision, etc.)
    	// When we hit a SECTION it becomes a little different: we increment the counter and we extract all the info we can from that Section
    	// We don't actually process "Step" here, nor any of the line types that comprise Steps/SubSteps, but we still increment the Step counter
    	// For simple line types, we just pass the entire "remainder" into the struct field
    	// For more complex line types, specialized functions take over and perform further processing of the remainder (and possibly the Section/Step counters)
        match trim_whitespace_make_uppercase(first_part).as_str() {
			"TEMPLATE" | "CSS" => new_proc.add_template(remainder),
			"NUMBER"	 	=> new_proc.set_number(remainder),
			"TITLE"		 	=> new_proc.set_title(remainder),
			"PROCESSTYPE"	=> new_proc.set_process_type(remainder),
			"AUTHOR"	 	=> new_proc.set_author(remainder),
			"REVIEWER"		=> new_proc.set_reviewer(remainder),
			"REVISION" | "REV" => new_proc.add_revision(remainder),
			"SUBJECT" 		=> new_proc.set_subject(remainder),
			"SUBJECTIMAGE"	=> new_proc.set_subject_image(remainder),
			"PRODUCT" 		=> new_proc.set_product(remainder),
			"PRODUCTIMAGE"	=> new_proc.set_product_image(remainder),

			"SECTION" | "SEC" => {
				new_proc.add_section(extract_next_section(&lines[ii..lines.len()],&file_name));
				sec_cnt += 1;
				stp_cnt = 0;
			},
			"SECTIONREFERENCE" | "SECREF" => {
				let (fetched_section,success) = fetch_section_reference(remainder);
				if success {
					new_proc.add_section(fetched_section);
					sec_cnt += 1;
					stp_cnt = 0;
				}
			},
			"STEP" | "STP" => {
				stp_cnt += 1;
			}

			"ACTION" | "DO"	=> (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"COMMAND" | "CMD" | ">" | "%" | "$" | "#"  => (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"CONTEXT" | "COMMENT" | "TXT" | "CMT" => (), 
			"IMAGE" | "IMG" | "PICTURE" | "PIC" | "FIGURE" | "FIG" => (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"WARNING" | "WARN" | "WAR" | "WRN" | "ALERT" | "!" => (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"CSVSTART"		=> (),
			"CSVEND"		=> (),
			"CSVFILE"		=> (),

			"VERIFICATION"| "VER" | "REQUIREMENT" | "REQ" => {
				new_proc.add_verification(parse_verification_line(remainder),"Step ".to_string()+&sec_cnt.to_string()+"."+&stp_cnt.to_string());
			},
			"RESOURCE" | "RES" => {
				new_proc.add_resource(parse_resource_line(remainder),"Step ".to_string()+&sec_cnt.to_string()+"."+&stp_cnt.to_string());
				new_proc.add_calibrated_resource(parse_resource_line(remainder));
			},
			"OBJECTIVE"	| "OBJ" => {
				new_proc.add_objective(remainder.to_string(),"Step ".to_string()+&sec_cnt.to_string()+"."+&stp_cnt.to_string());
			},
			"OUTOFSCOPE" | "OOS" => {
				new_proc.add_out_of_scope(remainder.to_string(),"Step ".to_string()+&sec_cnt.to_string()+"."+&stp_cnt.to_string());
			},
			""	=> (),
    		_ 	=> (),
        }

    }

    // Now that the Process information is extracted and placed into the struct, it's returned
    new_proc

}

/// Robustify string (slice) matching by trimming out all of the whitespace
/// 
/// Use it like this:
/// 
/// match **trim_whitespace_make_uppercase**(slice_to_compare)**.as_str()** {<br/>
/// 	"THING" => do_thing,<br/>
/// 	""		=> (),<br/>
/// 	_ 		=> (),<br/>
/// }
fn trim_whitespace_make_uppercase(s: &str) -> String { s.split_whitespace().collect::<Vec<_>>().join("").to_uppercase() }

/// Examine the remainder of lines in a file, and return the next Section
/// A Section is composed of a series of steps, so this is but one layer in that hierarchy
fn extract_next_section(some_lines:&[String],ebml_file:&str) -> Section {

	// Create a new, blank Section struct to fill with process information (Steps)
	let mut new_section:Section = Section::new();
	
	// We are scanning through lines looking for content within this section. Basically:
	//
	// Section|This Section
	// Step|First step in this section
	// ...|...
	// Section|Start of the NEXT Section--the line above this should be the last
	//
	// The hackey way we're doing this is with a counter, and after the counter gets to 1 (first Section) we're ready to terminate at the next one
	let mut section_count = 0;
	
	// Loop to break when we have more than one section, called 'one_section
	'one_section: for (ii,line) in some_lines.iter().enumerate() {

		// delimit the line by the bar/pipe character
    	let all_parts: Vec<&str> = line.split('|').collect();
    	// in this markup language, the text to the left of the first bar indicates what kind of line it is
    	let first_part: &str = all_parts[0];
    	// Everything to the right of the first bar is important for conditional data extraction (there could also be more pipes)
    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();
    	// "remainder" is everything to the right of the first bar, and a special case is handled here for a blank string (nothing) when there isn't anything to the right of the first bar
    	let remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };

    	match trim_whitespace_make_uppercase(first_part).as_str() {
    		// First encounter: name this Section with the content
			// Second encounter: stop!
			"SECTION" | "SEC" => { 
				section_count +=1;
				if section_count > 1 { break 'one_section };
				new_section.set_title(remainder);
				},
			"STEP" | "STP" => new_section.add_step(extract_next_step(&some_lines[ii..some_lines.len()],ebml_file)),
			// Conscious decision to ignore anything that isn't within a step (can change in the future?)
			// This logic also ignores comment lines, as the comment characters would polute the "Section" or "Step" text left of the bar/pipe
			_ => (),
		};
	}
	
	// Return the completed Section
	new_section

}

/// The Process contains a Section Reference, and this function carefully traverses the Library with best-effort to fetch it.
/// 
/// The sequence looks like this:
/// - Use globby finding to match folders to whatever the Process reference is
/// - If there is a match, read the file in a more careful way that [read_ebml] (don't follow further Section References)
/// - If the reference is to another reference, follow that reference to the next file, carefully that is...
/// - Limit the length of the daisy-chain to an arbitrary value
/// - If you successfully find the source "Section" that isn't itself a "Section Reference", then read that Section and return it
/// - Throw a flag to indicate success or failure
fn fetch_section_reference(remainder:&str) -> (Section,bool) {

	let max_layers:u8 = 4;
	let mut ref_layer:u8 = 0;
	let mut new_section = Section::new();
	let mut success:bool = false;
	let (first_stop, section_title) = parse_section_reference(remainder);

	let mut code:u8;

	// println!("'first_stop' --> [{}]",&first_stop);
	let mut next_stop = first_stop;

	while ref_layer < max_layers {
		ref_layer += 1;

		// println!("'ref_layer' --> [{}]",ref_layer);
		// println!("Inspecting [{}] for [{}] ... ",&next_stop,&section_title);
				
		(code,next_stop) = inspect_ebml_for_reference(&next_stop,&section_title);
		
		// println!("Code [{}] and 'next_stop' of [{}]",code,next_stop);
				
		match  code {
			0 => {
				new_section = take_section(&next_stop,&section_title);
				success = true;

				let folder_list = globify_document_number(&next_stop.to_string());
				if folder_list.len() > 0 {
					let rel_path = "../".to_owned() + &folder_list[0] + "/";
					// println!("Setting this section's relative_path field to [{}]",&rel_path);
					new_section.set_relative_path(&rel_path);
					// println!("Proof that it was done: get_relative_path() -> [{}]",new_section.get_relative_path());
				}
				break;
			},
			1 => {
				// do nothing in this case, because the loop will handle the next layer
			},
			2 => {
				new_section.set_title("ERR[Section Doesn't Exist in File]");
				success = false;
			},
			_ => {
				new_section.set_title("ERR[File Not Found]");
				success = false;
			}
		}
		if ref_layer == max_layers {
			new_section.set_title("ERR[Max Reference Depth Exceeded]");
			success = false;
		}

		// println!("");
	} 
	
	return (new_section,success);
}

/// For the "Section Reference" line type, there are two fields
/// 
/// - First field: external Process to reference
/// - Second field: Section 'title' to reference in that external file
/// 
/// This function expects 2 fields, but handles all cases.
fn parse_section_reference(remainder:&str) -> (String,String) {
	let all_parts: Vec<&str> = remainder.split('|').collect();
	match all_parts.len() {
		0 => ("ERROR: NO FILE FOUND".to_string(),"ERROR: NO SECTION TITLE FOUND".to_string()),
		1 => (all_parts[0].to_string().trim().to_string(),"ERROR: NO SECTION TITLE FOUND".to_string()),
		_ => (all_parts[0].to_string().trim().to_string(),all_parts[1].to_string().trim().to_string()),
	}
}

/// Inspect an external Process file to understand a specific Section Reference
/// 
/// This function returns a numeric code based on what it finds:
/// - 0 if section exists and is not a reference,
/// - 1 if section exists and is a reference,
/// - 2 if section doesn't exist in the file
/// - 3 if the file doesn't exist or can't be found
/// 
/// It also returns a String indicating what process to look into to find the referenced section. This is only necessary because the "daisy chaining" of references is in fact allowed. So for code "1" the returned String will be the *next* place to look for the source material.
fn inspect_ebml_for_reference(next_stop:&str,section_title:&str) -> (u8,String) {
	
	let folder_list = globify_document_number(&next_stop.to_string());

	if folder_list.len() > 0 {

		let file_to_read = "./".to_owned() + &folder_list[0] + "/" + &folder_list[0] + ".ebml";

		// println!("from 'inspect_ebml_for_reference' --> [{}]",&file_to_read);
		
		let lines = lines_from_file(file_to_read).expect("Could not load lines from Section Reference file");

		for line in lines {
	    	if line.trim().find("//") == Some(0) { continue }
	    	let all_parts: Vec<&str> = line.split('|').collect();
	    	let first_part: &str = all_parts[0];
	    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();
	    	let remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };
	    	
	    	match trim_whitespace_make_uppercase(first_part).as_str() {
				"SECTION" | "SEC" => {
					if trim_whitespace_make_uppercase(remainder) == trim_whitespace_make_uppercase(section_title) {
						// We found a valid reference, and it's the source we're looking for!
						return (0,next_stop.to_string());
					}
				},
				"SECTIONREFERENCE" | "SECREF" => {
					let (next_stop_candidate,section_title_candidate) = parse_section_reference(remainder);
					if trim_whitespace_make_uppercase(&section_title_candidate) == trim_whitespace_make_uppercase(section_title) {
						// We found a valid reference, and it's also a reference...
						return (1,next_stop_candidate.to_string());
					}
				},
				_ 	=> (),
	        }
		}

		// We didn't find the Section title
		return (2,"Section not found in reference file".to_string());

	// If you got this far, the folder list must be empty, e.g. folder_list.len() = 0
	} else {
		// The Process wasn't found
		return (3,"No Folder".to_string());
	}
}

/// Open a text file and return its lines as a Vec of String... well, wrapped in some Rust-y Result thing
fn lines_from_file(filename: impl AsRef<Path> + std::fmt::Debug) -> io::Result<Vec<String>> {
	// println!("from 'lines_from_file' --> [{:?}]\n",filename);
	BufReader::new(File::open(filename)?).lines().collect()
}

/// Attempt to find and return a single Section from a Process, *without* invoking [read_ebml]
/// 
/// Why avoid [read_ebml]? If a library is full of "Section Reference" lines, then there are certain cases that could branch infinitely if read_ebml tries to expand every Section Reference found. If *this* function did what [read_ebml] does, then it could spawn itself ad infinitum, and possibly recursively, and possibly circularly.
/// 
/// Therefore, we'll mimic what read_ebml does in this function, but *only* act on a single "Section" line (ignore "Section Reference" !!), being the first one found that matches the title we're looking for.
fn take_section(next_stop:&str,section_title:&str) -> Section {

	let folder_list = globify_document_number(&next_stop.to_string());

	let file_to_read = "./".to_owned() + &folder_list[0] + "/" + &folder_list[0] + ".ebml";
	
	// println!("Taking a Section from --> [{}]",&file_to_read);
	
	let lines = lines_from_file(file_to_read).expect("Could not load lines from Section Reference file");

		for (ii,line) in lines.iter().enumerate() {
			if line.trim().find("//") == Some(0) { continue }
	    	let all_parts: Vec<&str> = line.split('|').collect();
	    	let first_part: &str = all_parts[0];
	    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();
	    	let remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };
	    	
	    	match trim_whitespace_make_uppercase(first_part).as_str() {
				"SECTION" | "SEC" => {
					// Only act on the first Section whose title matches the one we're looking for
					if trim_whitespace_make_uppercase(remainder) == trim_whitespace_make_uppercase(section_title) {

						// build section like normal, just how read_ebml does it
						let ebml_file_proxy = "./".to_owned() + &folder_list[0].to_string() + "/proxy_file";
						return extract_next_section(&lines[ii..lines.len()],&ebml_file_proxy);
					}
				},
				// don't act on any other line type
				_ => (),
			}
		}

	// Fallback, though this should not ever occur.
	// If you get to 'take_section' then you have already confirmed that the Section you want is in this file.
	// You *should* be able to read the file and get the section...
	let mut new_section = Section::new();
	new_section.set_title("ERR[Unable to Reference Section, Cause Unknown]");
	return new_section; // should never happen...
}

/// When a "Step" line is encountered within a Section, this function performs an analogous extraction to "extract_next_section" but adapted for SubStep mining.
fn extract_next_step(few_lines:&[String],ebml_file:&str) -> Step {

	// Initialize the output, which is a single Step struct
	// The remainder of this routine will be filling this struct with the lines between the first Step and the next Step
	let mut new_step:Step = Step::new();
	
	// In order to know where to start and stop, initialize a counter for the Step
	let mut step_count = 0;

	// Consecutive Action rows are grouped into ActionSequence items, so this flag answers, "is the Action line I'm reading a FIRST action line?"
	// Every non-action line resets this to TRUE
	// When an Action line is encountered this is set to FALSE
	let mut allow_action = true;

	// Similar trick for "CSV Start"
	let mut allow_csv_start = true;
	
	// Named loop 'one_step is so named because when we find the second instance of Step then we're done
	'one_step: for (ii,line) in few_lines.iter().enumerate() {

		// delimit the line by the bar/pipe character
    	let all_parts: Vec<&str> = line.split('|').collect();
    	// in this markup language, the text to the left of the first bar indicates what kind of line it is
    	let first_part: &str = all_parts[0];
    	// Everything to the right of the first bar is important for conditional data extraction (there could also be more pipes)
    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();
    	// "remainder" is everything to the right of the first bar, and a special case is handled here for a blank string (nothing) when there isn't anything to the right of the first bar
    	let remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };

    	match trim_whitespace_make_uppercase(first_part).as_str() {
			// First encounter: name this step with the content
			// Second encounter: stop!
			"STEP" | "STP" => { 
				step_count +=1;
				if step_count > 1 { break 'one_step };
				new_step.set_text(remainder);
				allow_action = true;
				},
			// If the previous row was NOT an Action row, then start an ActionSequence fetch, which is analogous to this function
			// Otherwise, skip the Action row because it was already processed by the function that produces ActionSequence objects
			"ACTION" | "DO" => {
				if allow_action {
					new_step.add_sub_step(extract_next_action_sequence(&few_lines[ii..few_lines.len()]));
					allow_action = false;
				} else {()};
				},
			// Commands are simple: assume the entire text is the verbatim text to display as a command
			"COMMAND" | "CMD" | ">" | "%" | "$" | "#" => {
				new_step.add_sub_step(SubStep::Command(remainder.to_string()));
				allow_action = true;
				},
			// Image lines go to a subroutine that finds the image file name as well as the caption
			"IMAGE" | "IMG" | "PICTURE" | "PIC" | "FIGURE" | "FIG" => {
				new_step.add_sub_step(parse_image_line(remainder));
				allow_action = true;
				},
			// Warning lines are simple like Command lines: just use all the text as the Warning text
			"WARNING" | "WARN" | "WAR" | "WRN" | "ALERT" | "!" => {
				new_step.add_sub_step(SubStep::Warning(remainder.to_string()));
				allow_action = true;
				},
			// Verification lines are multi-part, so a subroutine is needed to make sense of the information
			"VERIFICATION"| "VER" | "REQUIREMENT" | "REQ" => {
				new_step.add_sub_step(SubStep::Verification(parse_verification_line(remainder)));
				allow_action = true;
				},
			// Resource is another simple line: all the text is the Resource name text
			// However, at the Step level there's a field that pulls in all resoureces from all steps, so we need to push that, too.
			"RESOURCE" | "RES" => {
				new_step.add_sub_step(SubStep::Resource(parse_resource_line(remainder)));
				// the line below is what pushes this found Resouce line up to the Step level field, as well as adding the SubStep
				new_step.add_resource(parse_resource_line(remainder));
				allow_action = true;
				},
			// Objective is another simple line of text
			"OBJECTIVE"	| "OBJ" => {
				new_step.add_sub_step(SubStep::Objective(remainder.to_string()));
				allow_action = true;
				},
			// "Out of Scope" is another simple line of text
			"OUTOFSCOPE" | "OOS" => {
				new_step.add_sub_step(SubStep::OutOfScope(remainder.to_string()));
				allow_action = true;
				},
			// Context is another simple line of text
			"CONTEXT" | "COMMENT" | "TXT" | "CMT" => {
				new_step.add_sub_step(SubStep::Context(remainder.to_string()));
				allow_action = true;
				},
			// Opening of a block of comma-separated values embedded in the EBML file to display as a table
			"CSVSTART" => {
				if allow_csv_start {
					new_step.add_sub_step(SubStep::Table(extract_embedded_csv(&few_lines[ii..few_lines.len()])));
					allow_csv_start = false;
				} else {()};
				},
			// Closing of a block of comma-separated values embedded in the EBML file
			"CSVEND" => allow_csv_start = true,
			// One-line call to reference an external file that contains comma-separated values to display as a table
			"CSVFILE" => new_step.add_sub_step(SubStep::Table(extract_external_csv(remainder,ebml_file))),
			// If there's any other kind of line, skip
			_ => (), 
		};
	}
	
	// Return the filled Step struct
	new_step

}

/// When an "Action" line is encountered within a Step, we want to group it with all consecutive Action lines that follow
/// 
/// The result is a type of SubStep called an ActionSequence
/// 
/// Action Sequences can be a single Action, or many actions
fn extract_next_action_sequence(couple_lines:&[String]) -> SubStep {

	// Initialize the vector of Actions that make up the ActionSequence type of SubStep
	let mut new_action_sequence:Vec<Action> = vec![];
	
	// Named loop 'consecutive_actions so named because the first non-Action will break the loop
	'consecutive_actions: for line in couple_lines.iter() {

		// delimit the line by the bar/pipe character
    	let all_parts: Vec<&str> = line.split('|').collect();
    	// in this markup language, the text to the left of the first bar indicates what kind of line it is
    	let first_part: &str = all_parts[0];
    	// Everything to the right of the first bar is important for conditional data extraction (there could also be more pipes)
    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();
    	// "remainder" is everything to the right of the first bar, and a special case is handled here for a blank string (nothing) when there isn't anything to the right of the first bar
    	let remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };

		match trim_whitespace_make_uppercase(first_part).as_str() {    	
			"ACTION" | "DO" => new_action_sequence.push(parse_action_line(remainder)),
			_ => break 'consecutive_actions,
		};
	}
	
	// Return the SubStep enum of type ActionSequence, with the Vec<Action> as the data
	SubStep::ActionSequence(new_action_sequence)

}

/// When "CSV Start" line is encountered, this function reads this first line all the way through the "CSV End" line that terminates that CSV block.
/// 
/// Additional information is contained within the "CSV Start" line itself in EBML bar delimiting syntax.
/// 
/// All lines between "CSV Start" and "CSV End" are assumed to be actual comma-separated value data rows, with the first row serving as a header row.
fn extract_embedded_csv(couple_lines:&[String]) -> Table {
	
	// Initialize the output
	let mut new_table = Table::new();

	// This flag is to fix an issue found in testing. Yay testing!
	let mut already_started = false;

	// Named loop 'csv_lines
	'csv_lines: for line in couple_lines.iter() {

		// delimit the line by the bar/pipe character
    	let all_parts: Vec<&str> = line.split('|').collect();
    	// in this markup language, the text to the left of the first bar indicates what kind of line it is
    	let first_part: &str = all_parts[0];
    	// Everything to the right of the first bar is important for conditional data extraction (there could also be more pipes)
    	let first_remainder: Vec<&str> = line.splitn(2,'|').collect();
    	// "remainder" is everything to the right of the first bar, and a special case is handled here for a blank string (nothing) when there isn't anything to the right of the first bar
    	let _remainder: &str = if first_remainder.len() > 1 { first_remainder[1] } else { "" };

		match (trim_whitespace_make_uppercase(first_part).as_str(),already_started) {    	
			("CSVSTART",false) => {
				match all_parts.len() {
					2 => new_table.set_caption(all_parts[1]),
					1 => (),
					_ => new_table.set_caption(all_parts[1]),
				}
			},
			("CSVEND",true) => break 'csv_lines,
			_ => {
				let csv_parts_str:Vec<&str> = line.split(',').collect();
				let mut new_row:Vec<String> = vec![];
				for ii in 0..csv_parts_str.len() {
					new_row.push(csv_parts_str[ii].to_string());
				}
				new_table.add_row(new_row);
			},
		};
		already_started = true;
	}

	// Return the Table struct
	new_table
}

/// When a single "CSV File" line is encountered, this function reads the informational parts, parsed with the pipe character, particularly the external file to reference and read in.
/// 
/// This function returns a Table object, and gets the "array" information from the referenced external file, and the "caption" information from the piped-through text in the single EBML line.
/// 
/// Critical assumption: the external CSV file is in the same folder as the EBML file that references it. This path is passed in as "ebml_file" and parsed within the function as such.
fn extract_external_csv(line:&str,ebml_file:&str) -> Table {
	
	/// Single-use private function within a private function to return the "array" information from a CSV file reference
	fn open_csv_file_and_return_data_array(file_name:&str) -> Vec<Vec<String>> {

		// empty string input (instead of the name of a file to read) returns a blank Process with no further processing
		if file_name==&String::from("") {
			return vec![];
		}

		match std::fs::exists(&file_name) {
			Ok(true) => (),
			_ => return vec![],
		}

		// Use the function to pull all the lines out of the markup file
		let lines = lines_from_file(file_name).expect("Could not load lines");

		let mut data_array:Vec<Vec<String>> = vec![];
		for line in lines {
			let mut new_csv_data_line:Vec<String> = vec![];
			let all_parts: Vec<&str> = line.split(',').collect();
			for part in all_parts {
				new_csv_data_line.push(part.trim_start().trim_end().to_string());
			}
			data_array.push(new_csv_data_line);
		}
		data_array
	}

	// Initialize the output
	let mut new_table = Table::new();
	let all_parts: Vec<&str> = line.split('|').collect();

	// TODO: robustify the lines below, because it's built on an unstable house of cards
	// println!("'ebml_file' --> [{}]",&ebml_file);
	let path_parts = ebml_file.split('/').collect::<Vec<_>>();
	// println!("'path_parts' --> [{:?}]",&path_parts);

	let csv_file_to_open = path_parts[0].to_owned() + "/" + path_parts[1] + "/" + all_parts[0].trim_start().trim_end();
	// println!("'csv_file_to_open' --> [{}]",csv_file_to_open);
	
	// One 'part' in the remainder means there's only a file reference in the CSV File line, e.g. "CSV File | file.csv"
	// Two 'parts' in the remainder means there's also a caption, e.g. "CSV File | file.csv | Caption text"
	// There can't be ZERO parts, and there isn't a definition of what third (or more) parts would be (yet), so treat the generic case the same as the "Two" case.
	match all_parts.len() {
		1 => {
			for row in open_csv_file_and_return_data_array(&csv_file_to_open) { new_table.add_row(row) };
		},
		2 => {
			for row in open_csv_file_and_return_data_array(&csv_file_to_open) { new_table.add_row(row) };
			new_table.set_caption(all_parts[1]);
		},
		_ => {
			for row in open_csv_file_and_return_data_array(&csv_file_to_open) { new_table.add_row(row) };
			new_table.set_caption(all_parts[1]);
		},
	}
	new_table // return the completed Table struct, complete with "array" and "caption" information
}

/// For a single Action line, extract the information and return an Action struct
fn parse_action_line(line:&str) -> Action {
	// Default value of "Two Party Verification" field is FALSE
	// delimit the line by the bar/pipe character
	let a: Vec<&str> = line.split('|').collect();
	match a.len() {
		2 => Action { perform:a[0].to_string(), expect:a[1].to_string(), tpv:false },
		1 => Action { perform:a[0].to_string(), expect:"ERROR: NO EXPECTED VALUE PROVIDED".to_string(), tpv:false },
		0 => Action { perform:"ERROR: NO ACTION PROVIDED".to_string(), expect:"ERROR: NO EXPECTED VALUE PROVIDED".to_string(), tpv:false },
		// 3 is expected, and the wildcard case covers 3 or more
		_ => Action { perform:a[0].to_string(), expect:a[1].to_string(), tpv: 
			match trim_whitespace_make_uppercase(a[2]).as_str() {
				"TPV"|"T"|"TRUE"|"Y"|"YES"|"TWOPARTYVERIFICATION"|"TWO-PARTYVERIFICATION" => true,
				_ => false,
			}
		},
	}
}


/// For an "Image" line, parse the two output pieces of information and return as an Image type SubStep
fn parse_image_line(line:&str) -> SubStep {

	// Delimit the input string by bar/pipe characters and respond based on the number of substrings
	let all_parts: Vec<&str> = line.split('|').collect();
	match all_parts.len() {
		
		// If only one string, then the image file and caption are the same
		// If only one string but it's empty, then include a default path and file name for a placeholder image
		1 => {
			if all_parts[0]=="" {
				return SubStep::Image("../assets/placeholderImage-small.png".to_string(),"../assets/placeholderImage-small.png".to_string())
			} else {
				return SubStep::Image(all_parts[0].to_string().trim().to_string(),all_parts[0].to_string().trim().to_string())
			}
		},
		// If for some reason the length of the segment vector is zero (??), then placeholder
		0 => return SubStep::Image("../assets/placeholderImage-small.png".to_string(),"../assets/placeholderImage-small.png".to_string()),
		// Two is expected here: the first is the image file name, and the second is the caption
		// Wildcard means 3 or more string segments, so use first two as in nominal path
		_ => {
			if all_parts[0]=="" {
				if all_parts[1]=="" {
					return SubStep::Image("../assets/placeholderImage-small.png".to_string(),"../assets/placeholderImage-small.png".to_string());
				} else {
					return SubStep::Image("../assets/placeholderImage-small.png".to_string(),all_parts[1].to_string().trim().to_string());
				}
			} else {
				if all_parts[1]=="" {
					return SubStep::Image(all_parts[0].to_string().trim().to_string(),all_parts[0].to_string().trim().to_string())
				} else {
					return SubStep::Image(all_parts[0].to_string().trim().to_string(),all_parts[1].to_string().trim().to_string())
				}				
			}
		},
	}

}

/// Verification lines have three expected pieces of information; this parsing function needs to be robust to all cases
fn parse_verification_line(line:&str) -> Requirement {

	// Delimit the input string by bar/pipe characters and respond based on the number of substrings
	let all_parts: Vec<&str> = line.split('|').collect();
	match all_parts.len() {
		// Two means we will pass an unknown string to the method, leaving that handling to the other function
		2 => return Requirement{id:all_parts[0].trim().to_string(),text:all_parts[1].trim().to_string(),method:which_method("???"),},
		// One string part means we don't have requirement text or method, so unknown values are filled
		1 => return Requirement{id:all_parts[0].trim().to_string(),text:"???".to_string(),method:which_method("???"),},
		0 => return Requirement{id:"???".to_string(),text:"???".to_string(),method:which_method("???"),},
		// Three is expected: ID field is first, then Requirement text, then the method of verificaiton (derived in another function)
		_ => return Requirement{id:all_parts[0].trim().to_string(),text:all_parts[1].trim().to_string(),method:which_method(all_parts[2].trim()),},
	}

}

/// Interpret a user string into an enum variant
fn which_method(m:&str) -> VerificationMethod {
	// Be robust and case insensitive
	// Commonly used terms for these verification methods are single letter e.g. D, I, A, S, T
	match trim_whitespace_make_uppercase(m).as_str() {
		"DEMONSTRATION"|"DEMO"|"D"	=> VerificationMethod::Demonstration,
		"INSPECTION"|"I"			=> VerificationMethod::Inspection,
		"ANALYSIS"|"A"				=> VerificationMethod::Analysis,
		"SAMPLING"|"SAMPLE"|"S"		=> VerificationMethod::Sampling,
		"TEST"|"T"					=> VerificationMethod::Test,
		// Sampling is the least expected of these for Stanhope processes
		// Making Sampling the default is a pseudo-flag that something is wrong
		// TODO: add an enum variant that covers the ??? case
		_ => VerificationMethod::Sampling,
	}
}

/// Pass the first part as the descriptive string for the resource
/// The second part is a flag to determine if this resource needs to be calibrated to be used in this process
fn parse_resource_line(line:&str) -> Resource {
	let all_parts: Vec<&str> = line.split('|').collect();

	let cal:bool = match all_parts.len() {
		0|1 => false,
		_ => match trim_whitespace_make_uppercase(all_parts[1]).as_str() {
				"C"|"CAL"|"CALIB"|"CALIBRATE"|"CALIBRATED"|"CALIBRATION"|"Y"|"YES"|"T"|"TRUE" => true,
				_ => false,
			}
	};

	match all_parts[0] {
		""	=> Resource { name: "ERROR: NO RESOURCE IDENTIFIED".to_string(), calibration:cal, },
		_ 	=> Resource { name: all_parts[0].to_string(), calibration:cal, },
	}
}


//  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄       ▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄           
// ▐░░░░░░░░░░░▌▐░░▌     ▐░░▌▐░░░░░░░░░░░▌▐░▌          
//  ▀▀▀▀█░█▀▀▀▀ ▐░▌░▌   ▐░▐░▌▐░█▀▀▀▀▀▀▀█░▌▐░▌          
//      ▐░▌     ▐░▌▐░▌ ▐░▌▐░▌▐░▌       ▐░▌▐░▌          
//      ▐░▌     ▐░▌ ▐░▐░▌ ▐░▌▐░█▄▄▄▄▄▄▄█░▌▐░▌          
//      ▐░▌     ▐░▌  ▐░▌  ▐░▌▐░░░░░░░░░░░▌▐░▌          
//      ▐░▌     ▐░▌   ▀   ▐░▌▐░█▀▀▀▀▀▀▀▀▀ ▐░▌          
//      ▐░▌     ▐░▌       ▐░▌▐░▌          ▐░▌          
//  ▄▄▄▄█░█▄▄▄▄ ▐░▌       ▐░▌▐░▌          ▐░█▄▄▄▄▄▄▄▄▄ 
// ▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░▌          ▐░░░░░░░░░░░▌
//  ▀▀▀▀▀▀▀▀▀▀▀  ▀         ▀  ▀            ▀▀▀▀▀▀▀▀▀▀▀ 

/// Functions necessary to create ::new() structs, as well as "get" every private field publicly, and to change or append private fields publicly
impl Process {

	/// Return Process struct with placeholder text in String fields, and empty vectors for Vec fields
	pub fn new() -> Process {
		Process {
			process_file: "".to_string(),
			number: "NO NUMBER IN EBML FILE - THIS IS PLACEHOLDER TEXT".to_string(),
			all_revisions: vec![],
			title: "NO TITLE IN EBML FILE".to_string(),
			process_type: "NO PROCESS TYPE IDENTIFIED IN EBML FILE".to_string(),
			author: "NO AUTHOR IN EBML FILE".to_string(),
			reviewer: "NO REVIEWER IN EBML FILE".to_string(),
			subject: "N/A".to_string(),
			subject_image: "N/A".to_string(),
			product: "N/A".to_string(),
			product_image: "N/A".to_string(),
			all_objectives: vec![],
			all_out_of_scopes: vec![],
			all_sections: vec![],
			all_resources: vec![],
			all_calibrated_resources: vec![],
			all_verifications: vec![],
			all_templates: vec![],
			full_source: vec![],
		}
	}

	/// Return reference to the **Process File** string
	pub fn get_process_file(&self) -> &String { &self.process_file }
	/// Return reference to the **Document Number** string
	pub fn get_number(&self) -> &String { &self.number }
	/// Return reference to the LATEST **Revision** (first listed in the markup file)
	pub fn get_revision(&self) -> &String { if self.all_revisions.len()==0 { &self.number } else { &self.all_revisions[0].0 } }
	/// Return reference to the vector of touples describing each Revision and what changed
	pub fn get_all_revisions(&self) -> &Vec<(String,String)> { &self.all_revisions }
	/// Return reference to the **Title** string
	pub fn get_title(&self) -> &String { &self.title }
	/// Return reference to the **Process Type** string
	pub fn get_process_type(&self) -> &String { &self.process_type }
	/// Return reference to the **Author** string
	pub fn get_author(&self) -> &String { &self.author }
	/// Return reference to the **Reviewer** string
	pub fn get_reviewer(&self) -> &String { &self.reviewer }
	/// Return reference to the **Subject** string
	pub fn get_subject(&self) -> &String { &self.subject }
	/// Return reference to the file name of an **Image of the Subject** as string
	pub fn get_subject_image(&self) -> &String { &self.subject_image }
	/// Return reference to the **Product** string
	pub fn get_product(&self) -> &String { &self.product }
	/// Return reference to the file name of an **Image of the Product** as string
	pub fn get_product_image(&self) -> &String { &self.product_image }
	/// Return reference to a **Vector of Sections**, in the order they appear in the markup
	pub fn get_all_sections(&self) -> &Vec<Section> { &self.all_sections }
	/// Return the total number of Steps throughout the process, including all Sections and Section References
	pub fn get_step_count(&self) -> usize {
		let mut stp_cnt:usize = 0;
		for sec in &self.all_sections {
			stp_cnt += sec.get_all_steps().len();
		}
		return stp_cnt;
	}
	/// Return reference to a **Vector of Requirement Tuples**, each with a Requirement struct and a string containing the Step number
	pub fn get_all_verifications(&self) -> &Vec<(Requirement,String)> { &self.all_verifications }
	/// Return reference to a **Vector of Tuples** describing each objective and at what step it is achieved
	pub fn get_all_objectives(&self) -> &Vec<(String,String)> { &self.all_objectives }
	/// Return reference to a **Vector of Tuples** describing each out-of-scope declaration and at from which step
	pub fn get_all_out_of_scopes(&self) -> &Vec<(String,String)> { &self.all_out_of_scopes }
	/// Return reference to a **Vector of Templates** as strings, one for each CSS file needed for the process
	pub fn get_all_templates(&self) -> &Vec<String> { &self.all_templates }
	/// Return reference to a **Vector of Resource Tuples**, each with a Resource struct and a string containing the Step number
	pub fn get_all_resources(&self) -> &Vec<(Resource,String)> { &self.all_resources }
	/// Return reference to a **Vector of Resources** (a unique set of only those that need calibration)
	pub fn get_all_calibrated_resources(&self) -> &Vec<Resource> { &self.all_calibrated_resources }
	/// Return the total number of Action lines that require Two-Party Verification (TPV)
	pub fn get_tpv_count(&self) -> usize {
		let mut counter:usize = 0;
		for sec in self.get_all_sections() {
			for stp in sec.get_all_steps() {
				for sub in stp.get_all_sub_steps() {
					match sub {
						SubStep::ActionSequence(acts) => {
							for act in acts {
								if act.get_tpv().clone() { counter += 1; }
							}
						},
						_ => (),
					}
				}
			}
		}
		counter
	}
	/// Return the total number of Action lines that don't require Two-Party Verification (no TPV)
	pub fn get_non_tpv_count(&self) -> usize {
		let mut counter:usize = 0;
		for sec in self.get_all_sections() {
			for stp in sec.get_all_steps() {
				for sub in stp.get_all_sub_steps() {
					match sub {
						SubStep::ActionSequence(acts) => {
							for act in acts {
								if !act.get_tpv().clone() { counter += 1; }
							}
						},
						_ => (),
					}
				}
			}
		}
		counter
	}
	/// Return a vector of string tuples, with every "Command" line's text (first element), with the step number (second element) in order of appearance in the process
	pub fn get_all_command_lines(&self) -> Vec<(String,String)> {
    	let mut all_command_lines = vec![];
    	let mut sec_count:u16 = 0;
		for sec in self.get_all_sections() {
			sec_count += 1;
			let mut step_count:u16 = 0;
			for stp in sec.get_all_steps() {
				step_count += 1;
				for sub in stp.get_all_sub_steps() {
					match sub {
						SubStep::Command(txt) => {
							all_command_lines.push((txt.to_string(),("Step ".to_owned()+&sec_count.to_string()+"."+&step_count.to_string()).to_string()));
						},
						_ => (),
					}
				}
			}
		}
		all_command_lines
	}
	/// Return a vector of string tuples, with every "Context" line's text (first element), with the step number (second element) in order of appearance in the process
	pub fn get_all_context_lines(&self) -> Vec<(String,String)> {
    	let mut all_context_lines = vec![];
    	let mut sec_count:u16 = 0;
		for sec in self.get_all_sections() {
			sec_count += 1;
			let mut step_count:u16 = 0;
			for stp in sec.get_all_steps() {
				step_count += 1;
				for sub in stp.get_all_sub_steps() {
					match sub {
						SubStep::Context(txt) => {
							all_context_lines.push((txt.to_string(),("Step ".to_owned()+&sec_count.to_string()+"."+&step_count.to_string()).to_string()));
						},
						_ => (),
					}
				}
			}
		}
		all_context_lines
	}
	/// Return extracted information from all SubStep "Image" variants as Vec of String tuples: (image file, caption text)
	pub fn get_all_images(&self) -> Vec<(String,String)> {
		let mut all_images = vec![];
		for sec in self.get_all_sections() { for stp in sec.get_all_steps() { for sub in stp.get_all_sub_steps() {
			match sub { SubStep::Image(file,caption) => all_images.push(((sec.get_relative_path().to_owned() + &file.to_string()).to_string(),caption.to_string())), _ => (), }
		}}}
		match self.get_subject_image().as_str() {
			"DEFAULT-PLACEHOLDER-IMAGE.png" | "N/A" | "" => (),
			_ => all_images.push((self.get_subject_image().to_string(),"Subject Image".to_string())),
		};
		match self.get_product_image().as_str() {
			"DEFAULT-PLACEHOLDER-IMAGE.png" | "N/A" | "" => (),
			_ => all_images.push((self.get_product_image().to_string(),"Product Image".to_string())),
		};
		return all_images;
	}
	/// Return a count of the number of unique image files invoked in this EBML file, including native "Image" lines, Subject Image, Product Image, and SECREFed "Image" lines
	pub fn get_unique_image_count(&self) -> usize {
		let (mut files, _captions): (Vec<_>, Vec<_>) = self.get_all_images().into_iter().map(|(a, b)| (a, b)).unzip();
		files.sort();
    	files.dedup();
    	return files.len();
	}
	/// Check to see if each image file needed for this process exists in the file system, and return a Vec of Strings of those that don't
	pub fn get_missing_images(&self) -> Vec<String> {
		let mut missing_images:Vec<String> = vec![];
		let (mut files, _captions): (Vec<_>, Vec<_>) = self.get_all_images().into_iter().map(|(a,b)| (a,b)).unzip();
		files.sort();
		files.dedup();
		let process_file = self.get_process_file();
		let process_file_parts:Vec<&str> = process_file.split('/').collect();
		let mut process_folder:String = String::from("");
		for (ii,process_file_part) in process_file_parts.clone().into_iter().enumerate() {
			if ii == 0 { process_folder.push_str(process_file_part); }
			else if ii+1 < process_file_parts.len() { process_folder.push_str(&("/".to_owned() + process_file_part)); }
		}
		for file in files { 
			let file_full = process_folder.to_owned() + "/" + &file.trim();
			//println!("Checking if [{}] exists...",&file);
			match std::fs::exists(&file_full) {
				Ok(true) => (),
		        Ok(false) => missing_images.push(file.trim().to_string()),
		        Err(e) => {
		        	missing_images.push(file.trim().to_string());
		        	eprintln!("Error checking file: {}",e);
		        },
	    	}
		}
		return missing_images;
	}
	/// Check to see if each image file needed for this process exists in the file system, and return a count of those that don't
	pub fn get_missing_image_count(&self) -> usize { self.get_missing_images().len() }
	/// Return a count of "Section Reference" or "SECREF" lines in this Process, prior to evaluating them into sections
	pub fn get_section_reference_count(&self) -> usize {
		let mut secref_cnt:usize = 0;
		let all_lines = self.get_full_source();
		for line in all_lines {
			let all_parts: Vec<&str> = line.split('|').collect();
			if all_parts.len() > 0 {
				match trim_whitespace_make_uppercase(all_parts[0]).as_str() {
					"SECTIONREFERENCE" | "SECREF" => secref_cnt+=1,
					_ => (),
				};
			}
		}
		return secref_cnt;
	} 
	/// Return the full source EBML of this process as a Vec of Strings, one String per line of EBML
	pub fn get_full_source(&self) -> &Vec<String> { &self.full_source }

	/// Used in verbose mode to display contents of the struct to stdout
	pub fn display_process_to_stdout(&self) {
		println!("\n== =================================================================");
		println!("==  {}",&self.get_title());
		if self.get_all_objectives().len() > 0 {
			println!("==   ↪ Objectives:");
			for (jj,(obj,_snum)) in self.get_all_objectives().into_iter().enumerate() {
				println!("==    {}. {}",jj+1,obj);
			}
		}
		println!("==   ↪ Document Number:           {}",&self.get_number());
		println!("==   ↪ Process Type:              {}",&self.get_process_type());
		println!("==   ↪ Current Revision:          {}",&self.get_revision());
		println!("==     ↪ Number of Revs:          {}",&self.get_all_revisions().len());
		println!("==   ↪ Author of this Rev:        {}",&self.get_author());
		println!("==   ↪ Reviewer of this Rev:      {}",&self.get_reviewer());
		println!("==\n==  Purpose and Objectives");
		println!("==   ↪ Subject of process:        {}",&self.get_subject());
		println!("==   ↪ Image of Subject:          {}",&self.get_subject_image());
		println!("==   ↪ Product produced:          {}",&self.get_product());
		println!("==   ↪ Image of Product:          {}",&self.get_product_image());
		println!("==   ↪ Count of Objectives:       {}",&self.get_all_objectives().len());
		println!("==   ↪ Count of Out of Scopes:    {}",&self.get_all_out_of_scopes().len());
		println!("==\n==  Process Structure");
		println!("==   ↪ Count of Templates:        {}",&self.get_all_templates().len());
		println!("==   ↪ Count of Sections:         {}",&self.get_all_sections().len());
		println!("==     ↪ Section References:      {}",&self.get_section_reference_count());
		println!("==   ↪ Count of Steps (total):    {}",&self.get_step_count());
		println!("==   ↪ Count of Resources:        {}",&self.get_all_resources().len());
		println!("==     ↪ Calibrated Resources:    {}",&self.get_all_calibrated_resources().len());
		println!("==   ↪ Count of Verifications:    {}",&self.get_all_verifications().len());
		println!("==   ↪ Count of Actions:          {}",&self.get_tpv_count()+&self.get_non_tpv_count());
		println!("==     ↪ TPV Actions:             {}",&self.get_tpv_count());
		println!("==     ↪ Non-TPV Actions:         {}",&self.get_non_tpv_count());
		println!("==   ↪ Count of Commands:         {}",&self.get_all_command_lines().len());
		println!("==   ↪ Count of Context lines:    {}",&self.get_all_context_lines().len());
		println!("==   ↪ Images (lines, sub, prod): {}",&self.get_all_images().len());
		println!("==     ↪ Unique images called:    {}",&self.get_unique_image_count());
		println!("==     ↪ Missing image files:     {}",&self.get_missing_image_count());
		if self.get_missing_image_count() > 0 {
			for (ii,image) in self.get_missing_images().into_iter().enumerate() {
				println!("==       [{}] {}",ii+1,&image);
			}
		}
		println!("== =================================================================\n");
	}

	/// Change the stored location of the EBML file for this process
	pub fn set_process_file(&mut self, file_name:&str) {
		self.process_file = String::from(file_name);
	}
	/// Change the Document Number
	pub fn set_number(&mut self, doc_num: &str) {
		self.number = String::from(doc_num.trim());
	}
	/// Add a Revision Tuple to the Vector "all_revisions"
	pub fn add_revision(&mut self, rev_line: &str) {
		// Delimit the line into its bar/piped chunks
		let chunks:Vec<&str> = rev_line.split('|').collect();
		// If the first chunk isn't an empty string, then use it (otherwise use default text)
		let rev_str = if !(chunks[0]=="") { chunks[0] } else { &"[No Rev]" };
		// Use the second chunk if it exists and isn't an empty string
		let chg_str = if chunks.len()<2 { &"[No description provided by Author]" } else if chunks[1]=="" { &"[No description provided by Author]" } else { chunks[1] };
		self.all_revisions.push((String::from(rev_str.trim()),String::from(chg_str.trim())));
	}
	/// Change the Document Title
	pub fn set_title(&mut self, title: &str) {
		self.title = String::from(title.trim());
	}
	/// Change the Process Type
	pub fn set_process_type(&mut self, process_type: &str) {
		self.process_type = String::from(process_type.trim());
	}
	/// Change the Document Author
	pub fn set_author(&mut self, author: &str) {
		self.author = String::from(author.trim());
	}
	/// Change the Document Reviewer
	pub fn set_reviewer(&mut self, reviewer: &str) {
		self.reviewer = String::from(reviewer.trim());
	}
	/// Change the Document Subject
	pub fn set_subject(&mut self, subject: &str) {
		self.subject = String::from(subject.trim());
	}
	/// Change the Image file name of the Document Subject
	pub fn set_subject_image(&mut self, subject_image: &str) {
		self.subject_image = String::from(subject_image.trim());
	}
	/// Change the Document Product
	pub fn set_product(&mut self, product: &str) {
		self.product = String::from(product.trim());
	}
	/// Change the Image file name of the Document Product
	pub fn set_product_image(&mut self, product_image: &str) {
		self.product_image = String::from(product_image.trim());
	}
	/// Add a Template file to the Vector of Template files (strings)
	pub fn add_template(&mut self, template: &str) {
		self.all_templates.push(String::from(template.trim()));
	}
	/// Add a Section to the Vector of Section structs
	pub fn add_section(&mut self, section: Section) {
		self.all_sections.push(section);
	}
	/// Add a Verification tuple to the Vector of Verification tuples
	pub fn add_verification(&mut self, requirement: Requirement, step:String) {
		self.all_verifications.push((requirement,step));
	}
	/// Add an Objective tuple to the Vector of Objective tuples
	pub fn add_objective(&mut self, objective:String, step:String) {
		self.all_objectives.push((objective,step));
	}
	/// Add an Out-of-Scope tuple to the Vector of Out-of-Scope tuples
	pub fn add_out_of_scope(&mut self, out_of_scope:String, step:String) {
		self.all_out_of_scopes.push((out_of_scope,step));
	}
	/// Add a Resource struct to the Vector of Resource structs
	pub fn add_resource(&mut self, resource: Resource, step:String) {
		self.all_resources.push((resource,step));
	}
	/// Add a Resource struct to the Vector of calibrated Resource structs
	pub fn add_calibrated_resource(&mut self, resource: Resource) {
		if *resource.get_calibration() { self.all_calibrated_resources.push(resource); }
	}
	/// Store the full text of the EBML file for this process as a Vec of Strings, one String per line of EBML
	pub fn set_full_source(&mut self, full_source: Vec<String>) {
		self.full_source = full_source;
	}
	
}

/// Section needs "get" and "set/add" functions as well, to read and write private fields
impl Section {

	/// Blank string for the title, and empty Vec initialized for the list of Steps
	fn new() -> Section {
		Section {
			title: "".to_string(),
			all_steps: vec![],
			relative_path: "".to_string(),
		}
	}

	/// Return reference to **Section Title** as string
	pub fn get_title(&self) -> &String { &self.title }
	/// Return reference to **Vector of Step structs**
	pub fn get_all_steps(&self) -> &Vec<Step> { &self.all_steps }
	/// Return the relative path from the Process folder to the Section's Process folder, only non-empty for SECREF feature
	pub fn get_relative_path(&self) -> &String { &self.relative_path }

	/// Change the **Section Title**
	fn set_title(&mut self, title: &str) {
		self.title = String::from(title);
	}
	/// Add a complete Step struct to the Vector of Step structs
	fn add_step(&mut self, step: Step) {
		self.all_steps.push(step);
	}
	/// Change the **Relative Path** from the Process folder to the Section's Process folder, especially if performing a SECREF fetch
	fn set_relative_path(&mut self, path:&str) {
		self.relative_path = String::from(path);
	}
}

/// Step needs "get" and "set/add" functions as well, to read and write private fields
impl Step {

	/// Empty string for the Step text, and empty vectors for 'resources' and 'all_sub_steps'
	pub fn new() -> Step {
		Step {
			text: "".to_string(),
			resources: vec![],
			all_sub_steps: vec![],
		}
	}

	/// Return reference to **Step text** as string
	pub fn get_text(&self) -> &String { &self.text }
	/// Return reference to **Vector of Resource structs** for this step
	pub fn get_resources(&self) -> &Vec<Resource> { &self.resources }
	/// Return reference to **Vector of SubStep structs** for all SubSteps in this Step
	pub fn get_all_sub_steps(&self) -> &Vec<SubStep> { &self.all_sub_steps }

	/// Change the text of this Step
	fn set_text(&mut self, text: &str) {
		self.text = String::from(text);
	}
	/// Add a complete SubStep to the ordered Vector of SubStep structs
	fn add_sub_step(&mut self, sub_step: SubStep) {
		self.all_sub_steps.push(sub_step);
	}
	/// Add a complete Resource struct to the ordered Vector of Resource structs
	fn add_resource(&mut self,r:Resource) {
		self.resources.push(r);
	}

}

/// Since Action structs are created directly in a function outside the struct at read-time, we just need "get" functions
impl Action {
	/// Return reference to the "Action to Perform" string
	pub fn get_perform(&self) -> &String { &self.perform }
	/// Return reference to the "Expected Outcome" string
	pub fn get_expect(&self) -> &String { &self.expect }
	/// Return reference to the "Two Party Verification" boolean
	pub fn get_tpv(&self) -> &bool { &self.tpv }
}

/// Since Requirement structs are created directly in a function outside the struct at read-time, we just need "get" functions
impl Requirement { 
	/// Return reference to the **Requirement ID** string
	pub fn get_id(&self) -> &String { &self.id }
	/// Return reference to the **Requirement Text** string
	pub fn get_text(&self) -> &String { &self.text }
	/// Return reference to the **Verification Method** as a string, even though that's not how's it's stored
	pub fn get_method(&self) -> String {
		// The Verification Method is stored as a VerificationMethod enum, so we need to map that to String values
		match &self.method {
			VerificationMethod::Demonstration => "Demonstration".to_string(),
			VerificationMethod::Inspection => "Inspection".to_string(),
			VerificationMethod::Analysis => "Analysis".to_string(),
			VerificationMethod::Sampling => "Sampling".to_string(),
			VerificationMethod::Test => "Test".to_string(),
		}
	}
}

/// Simple public "get" funciton for the one struct field
impl Resource {
	/// Return reference to the **Resource Name** string
	pub fn get_name(&self) -> &String { &self.name }

	/// Return the boolean that indicates if the resource requires calibration
	pub fn get_calibration(&self) -> &bool { &self.calibration }
}

/// Public "get" functions give access to the private fields. Private "set/add" functions are used within this module to construct the fields from a "new" Table struct.
impl Table {

	/// Empty string for the default caption, and an empty array for the default table data
	pub fn new() -> Table {
		Table {
			caption: "".to_string(),
			array: vec![],
		}
	}

	/// Return reference to the table caption
	pub fn get_caption(&self) -> &String { &self.caption }
	/// Change the table caption field
	fn set_caption(&mut self, caption: &str) {
		self.caption = String::from(caption.trim_start().trim_end());
	}

	/// Return a tuple with the number of rows and the number of columns in the table data array.
	/// 
	/// Assumptions:
	/// 1. if there are zero rows, there are zero columns
	/// 1. the number of columns in the first row is the number of columns that **should** be in every row
	pub fn get_size(&self) -> (usize,usize) {
		
		let rows = self.array.len();

		let columns:usize = match rows {
			0 => 0,
			_ => self.array[0].len(),
		};
		
		(rows,columns)
	}

	/// Return a vector with all cell contents for an indexed row number.
	/// 
	/// Example: to return the contents of the first row,
	/// > my_table.get_row(0)
	/// 
	/// Example: to return the conents of the 10th row,
	/// > my_table.get_row(9)
	pub fn get_row(&self,row_num:usize) -> Vec<String> {
		let (rows,_columns) = self.get_size();
		match &row_num <= &(rows-1) {
			true 	=> self.array[row_num].clone(),
			false 	=> panic!("table reference out of bounds"),
		}
	}

	/// Append the bottom of the table data array with another row of data.
	/// 
	/// Assumptions:
	/// 1. if this is the first row to be pushed, then it has the **correct** number of columns
	/// 1. if this is **not** the first row, then columns will be added from left-to-right until the **correct** number of columns is reached
	/// 1. if this new row has fewer than the **correct** number of columns, empty strings will fill in the righthand columns until the **correct** number is achieved
	fn add_row(&mut self,row:Vec<String>) {
		let (rows,columns) = self.get_size();
		match rows {
			0 => self.array.push(row),
			_ => {
				let mut new_row:Vec<String> = vec![];
				for ii in 0..columns {
					if ii < row.len() {
						new_row.push(row[ii].clone().trim_start().trim_end().to_string());
					} else {
						new_row.push("".to_string());
					}
				}
				self.array.push(new_row)
			},
		};
	}

}


//  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄ 
// ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌
//  ▀▀▀▀█░█▀▀▀▀ ▐░█▀▀▀▀▀▀▀▀▀ ▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀█░█▀▀▀▀ 
//      ▐░▌     ▐░▌          ▐░▌               ▐░▌     
//      ▐░▌     ▐░█▄▄▄▄▄▄▄▄▄ ▐░█▄▄▄▄▄▄▄▄▄      ▐░▌     
//      ▐░▌     ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌     
//      ▐░▌     ▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀█░▌     ▐░▌     
//      ▐░▌     ▐░▌                    ▐░▌     ▐░▌     
//      ▐░▌     ▐░█▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄█░▌     ▐░▌     
//      ▐░▌     ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌     
//       ▀       ▀▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀▀       ▀      

#[cfg(test)]
mod tests {
    // Note this useful idiom: importing names from outer (for mod tests) scope.
	use super::*;
	use std::fs;
	use std::fs::OpenOptions;
	use std::io::Write;

	// Test the struct impl functions
	#[test]
	fn test_process_new() {
		Process::new();
	}

	#[test]
    fn test_process_get_functions() {
		
		let p:Process = Process::new();

		assert_eq!(&p.number,p.get_number());
		println!("struct Process / Result of get_number() -> {:?}",p.get_number());

		assert_eq!(&p.process_type,p.get_process_type());
		println!("struct Process / Result of get_process_type() -> {:?}",p.get_process_type());
		
		assert_eq!(&p.number,p.get_revision());
		println!("struct Process / Result of get_revision() -> {:?}",p.get_revision());
		
		assert!(p.all_revisions.len()==0);
		let _is_right_type:&Vec<(String,String)> = p.get_all_revisions();
		println!("struct Process / Result of get_all_revisions() -> {:?}",p.get_all_revisions());

		assert_eq!(&p.title,p.get_title());
		println!("struct Process / Result of get_title() -> {:?}",p.get_title());

		assert_eq!(&p.author,p.get_author());
		println!("struct Process / Result of get_author() -> {:?}",p.get_author());

		assert_eq!(&p.reviewer,p.get_reviewer());
		println!("struct Process / Result of get_reviewer() -> {:?}",p.get_reviewer());

		assert_eq!(&p.subject,p.get_subject());
		println!("struct Process / Result of get_subject() -> {:?}",p.get_subject());

		assert_eq!(&p.subject_image,p.get_subject_image());
		println!("struct Process / Result of get_subject_image() -> {:?}",p.get_subject_image());

		assert_eq!(&p.product,p.get_product());
		println!("struct Process / Result of get_product() -> {:?}",p.get_product());

		assert_eq!(&p.product_image,p.get_product_image());
		println!("struct Process / Result of get_product_image() -> {:?}",p.get_product_image());

		assert_eq!(p.get_tpv_count(),0);
		println!("struct Process / Result of get_tpv_count() -> {:?}",p.get_tpv_count());

		assert_eq!(p.get_non_tpv_count(),0);
		println!("struct Process / Result of get_non_tpv_count() -> {:?}",p.get_non_tpv_count());

		assert!(p.all_sections.len()==0);
		let _is_right_type:&Vec<Section> = p.get_all_sections();
		println!("struct Process / Result of get_all_sections() -> [it's empty]");

		assert!(p.all_verifications.len()==0);
		let _is_right_type:&Vec<(Requirement,String)> = p.get_all_verifications();
		println!("struct Process / Result of get_all_sections() -> [it's empty]");

		assert!(p.all_templates.len()==0);
		let _is_right_type:&Vec<String> = p.get_all_templates();
		println!("struct Process / Result of get_all_templates() -> [it's empty]");

		assert!(p.all_resources.len()==0);
		let _is_right_type:&Vec<(Resource,String)> = p.get_all_resources();
		println!("struct Process / Result of get_all_resources() -> [it's an empty]");

		assert!(p.all_calibrated_resources.len()==0);
		let _is_right_type:&Vec<Resource> = p.get_all_calibrated_resources();
		println!("struct Process / Result of get_all_calibrated_resources() -> [it's an empty]");

		assert!(p.all_objectives.len()==0);
		let _is_right_type:&Vec<(String,String)> = p.get_all_objectives();
		println!("struct Process / Result of get_all_objectives() -> [it's an empty]");

		assert!(p.all_out_of_scopes.len()==0);
		let _is_right_type:&Vec<(String,String)> = p.get_all_out_of_scopes();
		println!("struct Process / Result of get_all_out_of_scopes() -> [it's an empty]");

	}

	#[test]
	fn test_process_display_process_to_stdout() {

		let p:Process = Process::new();
		p.display_process_to_stdout();

	}

	#[test]
	fn test_process_set_functions() {

		let mut p:Process = Process::new();

		p.set_number("SET_PROCESS_DOC_NUMBER");
		p.add_revision("SET_REV|SET_REV_CHANGE");
		p.set_title("SET_PROCESS_TITLE");
		p.set_author("SET_AUTHOR");
		p.set_reviewer("SET_REVIEWER");
		p.set_subject("SET_SUBJECT");
		p.set_subject_image("SET_SUBJECT_IMAGE");
		p.set_product("SET_PRODUCT");
		p.set_product_image("SET_PRODUCT_IMAGE");
		p.add_template("SET_TEMPLATE");
		p.add_section(Section{title:"SET_SECTION_TITLE".to_string(),all_steps:vec![],relative_path:"SET_SECTION_RELATIVE_PATH".to_string()});
		p.add_verification(Requirement{id:"SET_REQUIREMENT_ID".to_string(),text:"SET_REQUIREMENT_TEXT".to_string(),method:VerificationMethod::Sampling,},"SET_VERIFICATION_STEP".to_string());
		p.add_resource(Resource{name:"SET_RESOURCE_NAME".to_string(),calibration:false},"SET_RESOURCE_STEP".to_string());
		p.add_objective("SET_OBJECTIVE_TEXT".to_string(),"SET_OBJECTIVE_STEP".to_string());
		p.add_out_of_scope("SET_OBJECTIVE_TEXT".to_string(),"SET_OBJECTIVE_STEP".to_string());

		p.display_process_to_stdout();

	}

	#[test]
	fn test_section_new() {
		Section::new();
	}

	#[test]
	fn test_section_get_functions() {

		let s:Section = Section::new();

		assert_eq!(&s.title,s.get_title());
		println!("struct Section / Result of get_title() -> {:?}",s.get_title());

		assert!(s.get_all_steps().len()==0);
		let _is_right_type:&Vec<Step> = s.get_all_steps();
		println!("struct Section / Result of get_all_steps -> [it's empty]");

	}

	#[test]
	fn test_section_set_functions() {

		let mut s:Section = Section::new();

		s.set_title("SET_SECTION_TITLE");
		s.add_step(Step{text:"SET_SECTION_STEP_TEXT".to_string(),resources:vec![],all_sub_steps:vec![],});

	}

	#[test]
	fn test_step_new() {
		Step::new();
	}

	#[test]
	fn test_step_get_functions() {

		let stp:Step = Step::new();

		assert_eq!(&stp.text,stp.get_text());
		println!("struct Step / Result of get_text() -> {:?}",stp.get_text());

		assert!(stp.get_resources().len()==0);
		let _is_right_type:&Vec<Resource> = stp.get_resources();
		println!("struct Step / Result of get_resources() -> [it's empty]");

		assert!(stp.get_all_sub_steps().len()==0);
		let _is_right_type:&Vec<SubStep> = stp.get_all_sub_steps();
		println!("struct Step / Result of get_all_sub_steps() -> [it's empty]");

	}

	#[test]
	fn test_step_set_functions() {

		let mut stp:Step = Step::new();

		stp.set_text("SET_STEP_TEXT");
		stp.add_sub_step(SubStep::Warning("SET_STEP_SUB_STEP_WARNING".to_string()));
		stp.add_resource(Resource{name:"SET_STEP_SUB_STEP_RESOURCE".to_string(),calibration:false});

	}

	#[test]
	fn test_action_get_functions() {

		let a:Action = parse_action_line("ACTION|EXPECTED|TPV_TEXT");

		assert_eq!(&a.perform,a.get_perform());
		println!("struct Action / Result of get_perform() -> {:?}",a.get_perform());

		assert_eq!(&a.expect,a.get_expect());
		println!("struct Action / Result of get_expect() -> {:?}",a.get_expect());

		assert_eq!(&a.tpv,a.get_tpv());
		println!("struct Action / Result of get_tpv() -> {:?}",a.get_tpv());

	}

	#[test]
	fn test_requirement_get_functions() {

		let r:Requirement = parse_verification_line("RID|REQ_TEXT|VER_METH");

		assert_eq!(&r.id,r.get_id());
		println!("struct Requirement / Result of get_id() -> {:?}",r.get_id());

		assert_eq!(&r.text,r.get_text());
		println!("struct Requirement / Result of get_text() -> {:?}",r.get_text());

		assert_eq!("Sampling",r.get_method());
		println!("struct Requirement / Result of get_method() -> {:?}",r.get_method());

	}

	#[test]
	fn test_resource_get_functions() {

		let res:Resource = Resource{name:"RESOURCE_NAME".to_string(),calibration:false};

		assert_eq!(&res.name,res.get_name());
		println!("struct Resource / Result of get_name() -> {:?}",res.get_name());

		assert_eq!(&res.calibration,res.get_calibration());
		println!("struct Resource / Result of get_calibration() -> {:?}",res.get_calibration());

	}

	#[test]
	fn test_read_file_blank() {
		let _is_right_type:Process = read_ebml(&"".to_string());
	}

	// Some test-only functions for creating and destroying files to feed to read_ebml

	fn create_test_file(filename:&str, lines:Vec<String>) {
		let mut new_file = OpenOptions::new()
		            .read(true)
		            .write(true)
		            .create(true)
		            .open(filename)
		            .expect("Could not open the file!");
        for line in lines {
        	new_file.write({line+"\n"}.as_bytes()).expect("Could not write line to test-only file!");
        }
	}

	fn destroy_test_file(filename:&str) {
		let _ = fs::remove_file(filename);
	}

	fn generate_ebml_with_diabolical_comments() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("//".to_string());
		new_vec_of_strings.push("///".to_string());
		new_vec_of_strings.push("// /".to_string());
		new_vec_of_strings.push("/////////".to_string());
		new_vec_of_strings.push("//\\\\\\\\\\".to_string());
		new_vec_of_strings.push("\\\\Section|Section title".to_string());
		new_vec_of_strings.push("\n\n\n".to_string());
		new_vec_of_strings.push("//Section|This is a section! Maybe?".to_string());
		new_vec_of_strings.push("//Step|This is a step! Maybe?".to_string());
		new_vec_of_strings.push("\n\n\n".to_string());
		new_vec_of_strings.push("/ /".to_string());
		new_vec_of_strings.push("/Section/".to_string());
		new_vec_of_strings.push("/Section|Section title/".to_string());
		new_vec_of_strings.push("\n\n\n".to_string());
		new_vec_of_strings.push(" //".to_string());
		new_vec_of_strings.push(" / / / / / / / / ".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_1000_sections() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		for ii in 0..1000 {
			new_vec_of_strings.push("  sEc tIo      N  |Section ".to_string()+&(ii+1).to_string());
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_1000_steps_in_one_section() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1".to_string()];
		for ii in 0..1000 {
			new_vec_of_strings.push("  s T e P   |Step 1.".to_string()+&(ii+1).to_string());
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_1000_verifications_in_one_step() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		for ii in 0..1000 {
			new_vec_of_strings.push("  vEr iFi cAt iOn   |R".to_string()+&(ii+1).to_string()+"|Requirement text|demo");
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_1000_resources_in_one_step() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		for ii in 0..500 {
			new_vec_of_strings.push("  rEs oUr cE   |Really Important Tool #".to_string()+&(ii+1).to_string());
		}
		for ii in 500..1000 {
			new_vec_of_strings.push("  rEs oUr cE   |Really Important Tool #".to_string()+&(ii+1).to_string()+"|cal");
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_calibrated_resources() -> Vec<String> {
		// "C"|"CAL"|"CALIB"|"CALIBRATE"|"CALIBRATED"|CALIBRATION"|"Y"|"YES"|"T"|"TRUE"
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		new_vec_of_strings.push("Resource|Calibrated Resource|c    ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| c   ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|  c  ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|   c ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|    c".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|C    ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| C   ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|  C  ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|   C ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|    C".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| c    A    l    ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|CA    L".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| c a l i b ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| c a l i b rate ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| c a l i b rate  d ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource| c a l i b rat   ion ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|      y         ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|   y  e  s      ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|   t      ".to_string());
		new_vec_of_strings.push("Resource|Calibrated Resource|   t r u e   ".to_string());
		// 20 calibrated

		// And... one that isn't. So... this process should have 20 calibrated (but 21 total resources...)
		new_vec_of_strings.push("Resource|Calibrated Resource| nopey dopey!!! ".to_string());

		return new_vec_of_strings;

	}

	fn generate_ebml_with_1000_actions_in_one_step() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		for _ii in 0..1000 {
			new_vec_of_strings.push(" a CT i o N      |Thing to do|Thing to Expect|TPV".to_string());
			//new_vec_of_strings.push("Action|Thing to do|Thing to Expect|TPV".to_string());
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_300_tpv_700_non_tpv_actions_in_one_step() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		for _ii in 0..300 {
			new_vec_of_strings.push(" aC  tI  oN |Thing to do|Thing to Expect|TPV".to_string());
		}
		for _ii in 0..700 {
			new_vec_of_strings.push("actio      N|Thing to do|Thing to Expect".to_string());
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_1000_objectives_in_one_step() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		for ii in 0..1000 {
			new_vec_of_strings.push("    o Bj   eCt  i   v   E    |This is the point of the procedure, number ".to_string()+&(ii+1).to_string());
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_with_1000_out_of_scopes_in_one_step() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec!["Section|Section 1\nStep|Step 1.1".to_string()];
		for ii in 0..1000 {
			new_vec_of_strings.push("   oU To        FsCo P e  |This is yet another thing we DON'T do here, number ".to_string()+&(ii+1).to_string());
		}
		return new_vec_of_strings;
	}

	fn generate_ebml_set_meta_twice() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Number|First Number".to_string());
		new_vec_of_strings.push("Number|Second Number".to_string());
		new_vec_of_strings.push("Title|First Title".to_string());
		new_vec_of_strings.push("Title|Second Title".to_string());
		new_vec_of_strings.push("Author|First Author".to_string());
		new_vec_of_strings.push("Author|Second Author".to_string());
		new_vec_of_strings.push("Reviewer|First Reviewer".to_string());
		new_vec_of_strings.push("Reviewer|Second Reviewer".to_string());
		new_vec_of_strings.push("Subject|First Subject".to_string());
		new_vec_of_strings.push("Subject|Second Subject".to_string());
		new_vec_of_strings.push("SubjectImage|First SubjectImage".to_string());
		new_vec_of_strings.push("SubjectImage|Second SubjectImage".to_string());
		new_vec_of_strings.push("Product|First Product".to_string());
		new_vec_of_strings.push("Product|Second Product".to_string());
		new_vec_of_strings.push("ProductImage|First ProductImage".to_string());
		new_vec_of_strings.push("ProductImage|Second ProductImage".to_string());
		new_vec_of_strings.push("ProcessType|First ProcessType".to_string());
		new_vec_of_strings.push("ProcessType|Second ProcessType".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_whitespace_first_part() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|Section Title".to_string());
		new_vec_of_strings.push(" Section|Section Title".to_string());
		new_vec_of_strings.push("  Section|Section Title".to_string());
		new_vec_of_strings.push("Section |Section Title".to_string());
		new_vec_of_strings.push("Section  |Section Title".to_string());
		new_vec_of_strings.push(" Section |Section Title".to_string());
		new_vec_of_strings.push(" S e c t i o n |Section Title".to_string());
		new_vec_of_strings.push("Sec      ti        on       |Section Title".to_string());
		new_vec_of_strings.push(" S                    ection|Section Title".to_string());
		new_vec_of_strings.push("Section|Section Title".to_string());
		// 10 total
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_section_and_step_triggers() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// Three sections, each with three steps, let's get goofy AF
		new_vec_of_strings.push("Section |Section Title".to_string());
		new_vec_of_strings.push(" S t e p |Step Text".to_string());
		new_vec_of_strings.push(" A c t i o n |Do This|Expect This|TPV".to_string());
		new_vec_of_strings.push(" C o m m a n d |Command Text".to_string());
		new_vec_of_strings.push(" I m a g e |ImageFile.Ext|Image Caption".to_string());
		new_vec_of_strings.push(" W a r n i n g |Warning Text".to_string());
		new_vec_of_strings.push(" V e r i f i c a t i o n |RID|Req Text|T".to_string());
		new_vec_of_strings.push(" R e s o u r c e |Resource Text".to_string());
		new_vec_of_strings.push("St  ep   |Step Text".to_string());
		new_vec_of_strings.push("Com man d|Command Text".to_string());
		new_vec_of_strings.push("     Step|Step Text".to_string());
		new_vec_of_strings.push(" Command |Command Text".to_string());
		new_vec_of_strings.push(" S e c t i o n |Section Title".to_string());
		new_vec_of_strings.push("St ep|Step Text".to_string());
		new_vec_of_strings.push("C om ma n d|Command Text".to_string());
		new_vec_of_strings.push("St  ep|Step Text".to_string());
		new_vec_of_strings.push("Command          |Command Text".to_string());
		new_vec_of_strings.push("St   ep|Step Text".to_string());
		new_vec_of_strings.push(" command |Command Text".to_string());
		new_vec_of_strings.push("SECTION|Section Title".to_string());
		new_vec_of_strings.push("STEP|Step Text".to_string());
		new_vec_of_strings.push(" C O M M A N D|Command Text".to_string());
		new_vec_of_strings.push("S T E P |Step Text".to_string());
		new_vec_of_strings.push("   CO   MM   AND   |Command Text".to_string());
		new_vec_of_strings.push("ST   EP|Step Text".to_string());
		new_vec_of_strings.push(" c o MM a n D     |Command Text".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_actions() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section, three Steps, one ActionSequence apiece
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|lots of bars".to_string());
		// ActionSequence should have length 6
		new_vec_of_strings.push("Action|Nominal|Nominal|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|TPV|".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|TPV||".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|TPV|||".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|TPV||||".to_string());
		new_vec_of_strings.push("Action|||TPV|||".to_string());
		new_vec_of_strings.push("Step|push the TPV limits - all should be true".to_string());
		// ActionSequence should have length 12
		new_vec_of_strings.push("Action|Nominal|Nominal|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|tpv".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|TRUE".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|true".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|T".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|t".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|Two Party Verification".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|Y".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|y".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|Yes".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|yes".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|YES".to_string());
		new_vec_of_strings.push("Step|these TPVs should be false".to_string());
		// ActionSequence should have length 8
		new_vec_of_strings.push("Action|Nominal|TPV".to_string());
		new_vec_of_strings.push("Action|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|naw|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|naw|??|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|naw|??|??|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal||??|??|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal|||??|TPV".to_string());
		new_vec_of_strings.push("Action|Nominal|Nominal||||TPV".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_verification_methods() -> Vec<String> {
 		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|Analysis".to_string());
		// First step has 7 Verification SubSteps, all of them with VerificationMethod of Analysis
		new_vec_of_strings.push("Verification|A001|Analysis|Analysis".to_string());
		new_vec_of_strings.push("VERIFICATION|A002|Analysis|ANALYSIS".to_string());
		new_vec_of_strings.push("verification|A003|Analysis|analysis".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |A004|Analysis| a n a l y s i s".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |A005|Analysis| a n a l y s i s | test |demo|sampling|inspection".to_string());
		new_vec_of_strings.push("Verification|A006|Analysis|A".to_string());
		new_vec_of_strings.push("Verification|A007|Analysis|        a".to_string());
		new_vec_of_strings.push("Step|Inspection".to_string());
		// Second step has 7 Verification SubSteps, all of them with VerificationMethod of Inspection
		new_vec_of_strings.push("Verification|I001|Inspection|Inspection".to_string());
		new_vec_of_strings.push("VERIFICATION|I002|Inspection|INSPECTION".to_string());
		new_vec_of_strings.push("verification|I003|Inspection|inspection".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |I004|Inspection| i n s p e c t i o n".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |I005|Inspection| i n s p e c t i o n | test |demo|sampling|analysis".to_string());
		new_vec_of_strings.push("Verification|I006|Inspection|I".to_string());
		new_vec_of_strings.push("Verification|I007|Inspection|        i".to_string());
		new_vec_of_strings.push("Step|Test".to_string());
		// Third step has 7 Verification SubSteps, all of them with VerificationMethod of Test
		new_vec_of_strings.push("Verification|T001|Test|Test".to_string());
		new_vec_of_strings.push("VERIFICATION|T002|Test|TEST".to_string());
		new_vec_of_strings.push("verification|T003|Test|test".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |T004|Test| t e s t".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |T005|Test| t e s t | analysis |demo|sampling|inspection".to_string());
		new_vec_of_strings.push("Verification|T006|Test|T".to_string());
		new_vec_of_strings.push("Verification|T007|Test|        t".to_string());
		new_vec_of_strings.push("Step|Sampling".to_string());
		// Third step has 9 Verification SubSteps, all of them with VerificationMethod of Sampling
		new_vec_of_strings.push("Verification|S001|Sampling|Sampling".to_string());
		new_vec_of_strings.push("VERIFICATION|S002|Sampling|SAMPLING".to_string());
		new_vec_of_strings.push("verification|S003|Sampling|sampling".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |S004|Sampling| s a m p l i n g".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |S005|Sampling| s a m p l i n g | analysis |demo|TEst|inspection".to_string());
		new_vec_of_strings.push("Verification|S006|Sampling|S".to_string());
		new_vec_of_strings.push("Verification|S007|Sampling|        s".to_string());
		new_vec_of_strings.push("Verification|S008|Sampling| SAMPLE".to_string());
		new_vec_of_strings.push("Verification|S009|Sampling|        s a m PLE   ".to_string());
		new_vec_of_strings.push("Step|Demonstration".to_string());
		// Third step has 9 Verification SubSteps, all of them with VerificationMethod of Demonstration
		new_vec_of_strings.push("Verification|D001|Demonstration|Demonstration".to_string());
		new_vec_of_strings.push("VERIFICATION|D002|Demonstration|DEMONSTRATION".to_string());
		new_vec_of_strings.push("verification|D003|Demonstration|demonstration".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |D004|Demonstration| d e m o n s t r a t i o n".to_string());
		new_vec_of_strings.push("v e r i f i c a t i o n |D005|Demonstration| d e m o n s t r a t i o n | analysis |test|sampling|inspection".to_string());
		new_vec_of_strings.push("Verification|D006|Demonstration|D".to_string());
		new_vec_of_strings.push("Verification|D007|Demonstration|        d".to_string());
		new_vec_of_strings.push("Verification|D007|Demonstration| DEMO".to_string());
		new_vec_of_strings.push("Verification|D007|Demonstration|        d EM o   ".to_string());
		/*
		"DEMONSTRATION"|"DEMO"|"D"	=> VerificationMethod::Demonstration,
		"INSPECTION"|"I"			=> VerificationMethod::Inspection,
		"ANALYSIS"|"A"				=> VerificationMethod::Analysis,
		"SAMPLING"|"SAMPLE"|"S"		=> VerificationMethod::Sampling,
		"TEST"|"T"					=> VerificationMethod::Test,
		*/
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_image_lines() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|Strange three-part image lines".to_string());
		// First step has 5 Images
		new_vec_of_strings.push("Image|filename.ext|Caption".to_string());
		new_vec_of_strings.push("IMAGE|filename.ext|Caption".to_string());
		new_vec_of_strings.push("image|filename.ext|Caption".to_string());
		new_vec_of_strings.push("  iM  Ag     E   |filename.ext|Caption".to_string());
		new_vec_of_strings.push("           IMage |filename.ext|Caption".to_string());

		new_vec_of_strings.push("Step|lots of bars, empty parts".to_string());
		// Second step has 5 Images, all of which should have default text for filename and Caption
		new_vec_of_strings.push("image |".to_string());
		new_vec_of_strings.push("image ||".to_string());
		new_vec_of_strings.push("image |||".to_string());
		new_vec_of_strings.push("image ||||".to_string());
		new_vec_of_strings.push("image |||||||||||||||".to_string());

		new_vec_of_strings.push("Step|lots of bars, empty parts".to_string());
		// Third step has 5 Images, all of which should have default text for filename and Caption
		new_vec_of_strings.push("image |||filename.ext|Caption".to_string());
		new_vec_of_strings.push("image ||||filename.ext|Caption".to_string());
		new_vec_of_strings.push("image |||||filename.ext|Caption".to_string());
		new_vec_of_strings.push("image ||||||filename.ext|Caption".to_string());
		new_vec_of_strings.push("image |||||||filename.ext|Caption".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_diabolical_resources() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|Strange resource lines".to_string());
		// First step has 5 Resources
		new_vec_of_strings.push("Resource|Nominal".to_string());
		new_vec_of_strings.push("RESOURCE|Nominal".to_string());
		new_vec_of_strings.push("resource|Nominal".to_string());
		new_vec_of_strings.push(" r e s o u r c e |Nominal".to_string());
		new_vec_of_strings.push(" rEs oUr cE      |Nominal".to_string());
		new_vec_of_strings.push("Step|Strange resource lines".to_string());
		// First step has 5 Resources
		new_vec_of_strings.push("Resource|".to_string());
		new_vec_of_strings.push("RESOURCE||".to_string());
		new_vec_of_strings.push("resource|||".to_string());
		new_vec_of_strings.push(" r e s o u r c e ||||".to_string());
		new_vec_of_strings.push(" rEs oUr cE      |||||".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_embedded_1000_rows() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|Strange resource lines".to_string());
		// First step has one embedded CSV table
		new_vec_of_strings.push("CSV Start | Caption text".to_string());
		for _ in 0..1000 {
			new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		}
		new_vec_of_strings.push("CSV End |".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_embedded_rows_wrong_lengths() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|One and only step".to_string());
		// First step has one embedded CSV table
		new_vec_of_strings.push("CSV Start | Caption text".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five".to_string());
		new_vec_of_strings.push("One,Two,Three,Four".to_string());
		new_vec_of_strings.push("One,Two,Three".to_string());
		new_vec_of_strings.push("One,Two".to_string());
		new_vec_of_strings.push("One".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve,Thirteen".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve,Thirteen,Fourteen".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve,Twelve,Thirteen,Fourteen,Fifteen".to_string());
		new_vec_of_strings.push("CSV End |".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_embedded_edge_cases() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|One and only step".to_string());
		// First step has one embedded CSV table
		new_vec_of_strings.push("CSV Start | Caption text".to_string());
		new_vec_of_strings.push("CSV Start | This is one effed-up CSV line, tell you what. It's meant to look like EBML, but it isn't!!!".to_string());
		new_vec_of_strings.push("Wait, so you're saying the line above is CSV and not EBML?".to_string());
		new_vec_of_strings.push("Yes, that's exactly what I'm saying. YOU are even a CSV line, my friend.".to_string());
		new_vec_of_strings.push("Me? You're saying that THIS is also a CSV line? If so, how many columns are in this line?".to_string());
		new_vec_of_strings.push("Two. You see, When you said, 'If so,' you used a comma. In fact, in this line alone I've used four.".to_string());
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Second
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Third
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Fourth
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Fifth
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Sixth
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Seventh
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("".to_string());
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("Command | rm -rf lol".to_string());	 // Eigth SUBSTEP (first command)
		new_vec_of_strings.push("CSV Start | Caption text".to_string()); // Ninth SUBSTEP (eighth table...)
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push(",,,,CUCU,,,,,".to_string()); // That's the fifth column in the fourth row, of the ninth substep...
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push(",,,,,,,,,,,,,".to_string());
		new_vec_of_strings.push("CSV End |".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_embedded_no_end_line() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|One and only step".to_string());
		// First step has one embedded CSV table, but the "Start" line is missing
		new_vec_of_strings.push("CSV Start | Caption text".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());	
		// new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("WARNING | This SHOULD be picked up as a SubStep, even though the CSV lines below will be picked up in the SubStep above...".to_string());
		new_vec_of_strings.push("WARNING | This SHOULD be picked up as a SubStep, even though the CSV lines below will be picked up in the SubStep above...".to_string());
		new_vec_of_strings.push("WARNING | This SHOULD be picked up as a SubStep, even though the CSV lines below will be picked up in the SubStep above...".to_string());
		new_vec_of_strings.push("CSV Start | This SHOULD be read as a CSV line for the ONE table SubStep...".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		//new_vec_of_strings.push("CSV End |".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_embedded_no_start_line() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|One and only step".to_string());
		// First step has one embedded CSV table, but the "Start" line is missing
		//new_vec_of_strings.push("CSV Start | Caption text".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five".to_string());
		new_vec_of_strings.push("One,Two,Three,Four".to_string());
		new_vec_of_strings.push("One,Two,Three".to_string());
		new_vec_of_strings.push("One,Two".to_string());
		new_vec_of_strings.push("One".to_string());
		new_vec_of_strings.push("Context | Since the CSV Start line is missing, this should be the first SubStep that registers... a Context line.".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve,Thirteen".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve,Thirteen,Fourteen".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Eleven,Twelve,Twelve,Thirteen,Fourteen,Fifteen".to_string());
		new_vec_of_strings.push("CSV End |".to_string());
		new_vec_of_strings.push("WARNING | This is the second SubStep that should be found...".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_external() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|One and only step".to_string());
		new_vec_of_strings.push("CSV File | test.csv | Caption text".to_string());
		new_vec_of_strings.push("WARNING | This is the second SubStep that should be found...".to_string());
		new_vec_of_strings.push("WARNING | This is the third SubStep that should be found...".to_string());
		new_vec_of_strings.push("WARNING | This is the fourth SubStep that should be found...".to_string());
		return new_vec_of_strings;
	}

	fn generate_csv_table_external() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("H1,H2,H3".to_string());
		new_vec_of_strings.push("D1,D2,D3".to_string());
		new_vec_of_strings.push("D4,D5,D6".to_string());
		new_vec_of_strings.push("D7,D8,D9".to_string());
		return new_vec_of_strings;
	}

	fn generate_ebml_with_csv_table_external_stressing() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		// One Section
		new_vec_of_strings.push("Section |The one and only section".to_string());
		new_vec_of_strings.push("Step|One and only step".to_string());

		// First five valid SubStep lines: nominal... call an external file
		new_vec_of_strings.push("CSV File | test.csv | Caption text".to_string());
		new_vec_of_strings.push("      C S V  F i l e        |        test.csv            |           Caption text          ".to_string());
		new_vec_of_strings.push("csvfile|test.csv|Caption text".to_string());
		new_vec_of_strings.push("  cSvFiLe  |    test.csv| Caption text".to_string());
		new_vec_of_strings.push("CSV File | test.csv | Caption text".to_string());

		// False SubSteps that won't be counted: typos
		new_vec_of_strings.push("CSVee File | test.csv | Caption text".to_string());
		new_vec_of_strings.push("CSV Flie | test.csv | Caption text".to_string());
		new_vec_of_strings.push("CSV Fille | test.csv | Caption text".to_string());
		new_vec_of_strings.push("CVS File | test.csv | Caption text".to_string());
		new_vec_of_strings.push("Cee Ess Vee File | test.csv | Caption text".to_string());

		// Valid "embedded" CSV file call, with an "external" CSV call within it, which will be TWO SubSteps... but not more...
		// Furthermore, the "embedded" one will count the "external" CSV EBML line as one of its CSV lines... so it will have 3 rows...
		new_vec_of_strings.push("CSV Start | Caption text".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("CSV File | test.csv | Caption text".to_string());
		new_vec_of_strings.push("One,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten".to_string());
		new_vec_of_strings.push("CSV End |".to_string());

		// Running totals:
		// One Section
		// One Step
		// Seven SubSteps, all tables
		// > 0-4 : (4,3)
		// > 5   : (3,10)
		// > 6   : (4,3)
		return new_vec_of_strings;
	}
	
	// end test-only functions	
	
	#[test]
	fn test_read_file_all_comments() {
		let file_name = "test_comments_only.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_comments());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),0);
		assert_eq!(process.get_all_resources().len(),0);
		assert_eq!(process.get_all_verifications().len(),0);
		assert_eq!(process.get_all_templates().len(),0);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_set_process_meta_twice() {
		let file_name = "test_process_meta_set_twice.ebml".to_string();
		create_test_file(&file_name,generate_ebml_set_meta_twice());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_number(),"Second Number");
		assert_eq!(process.get_title(),"Second Title");
		assert_eq!(process.get_author(),"Second Author");
		assert_eq!(process.get_reviewer(),"Second Reviewer");
		assert_eq!(process.get_subject(),"Second Subject");
		assert_eq!(process.get_subject_image(),"Second SubjectImage");
		assert_eq!(process.get_product(),"Second Product");
		assert_eq!(process.get_product_image(),"Second ProductImage");
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_sections() {
		let file_name = "test_1000_sections.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_sections());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1000);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_steps() {
		let file_name = "test_1000_steps.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_steps_in_one_section());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1000);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_verifications() {
		let file_name = "test_1000_verifications.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_verifications_in_one_step());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_verifications().len(),1000);
		assert_eq!(process.get_all_verifications()[500].1,"Step 1.1");
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_resources() {
		let file_name = "test_1000_resources.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_resources_in_one_step());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_resources().len(),1000);
		assert_eq!(process.get_all_calibrated_resources().len(),500);
		assert_eq!(process.get_all_resources()[500].1,"Step 1.1");
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_actions() {
		let file_name = "test_1000_actions.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_actions_in_one_step());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),1);
		match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::ActionSequence(list) => assert_eq!(list.len(),1000),
			_ => assert!(1==0),
		};		
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_300_tpv_700_non_tpv() {
		let file_name = "test_300_tpv_700_non_tpv.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_300_tpv_700_non_tpv_actions_in_one_step());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_tpv_count(),300);
		assert_eq!(process.get_non_tpv_count(),700);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_objectives(){
		let file_name = "test_1000_objectives.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_objectives_in_one_step());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_objectives().len(),1000);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_1000_out_of_scopes(){
		let file_name = "test_1000_out_of_scopes.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_out_of_scopes_in_one_step());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_out_of_scopes().len(),1000);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_read_file_whitespace_first_part() {
		let file_name = "test_whitespace_first_part.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_whitespace_first_part());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),10);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_extract_section_and_step_triggers() {
		let file_name = "test_extract_section_triggers.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_section_and_step_triggers());
		let process = read_ebml(&file_name);
		// SHOULD BE: Three Sections, each with three Steps, but formatted hella goofy
		assert_eq!(process.get_all_sections().len(),3);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),3);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),6);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[1].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[2].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[1].get_all_steps().len(),3);
		assert_eq!(process.get_all_sections()[1].get_all_steps()[0].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[1].get_all_steps()[1].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[1].get_all_steps()[2].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[2].get_all_steps().len(),3);
		assert_eq!(process.get_all_sections()[2].get_all_steps()[0].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[2].get_all_steps()[1].get_all_sub_steps().len(),1);
		assert_eq!(process.get_all_sections()[2].get_all_steps()[2].get_all_sub_steps().len(),1);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_action_lines() {
		let file_name = "test_action_lines.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_actions());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),3);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep {
				SubStep::ActionSequence(list) => {
					assert_eq!(list.len(),6);
					for a in list { assert_eq!(a.get_tpv(),&true); }
				},
				_ => (),
			}
		}
		for substep in process.get_all_sections()[0].get_all_steps()[1].get_all_sub_steps() {
			match substep {
				SubStep::ActionSequence(list) => {
					assert_eq!(list.len(),12);
					for a in list { assert_eq!(a.get_tpv(),&true); }
				},
				_ => (),
			}
		}
		for substep in process.get_all_sections()[0].get_all_steps()[2].get_all_sub_steps() {
			match substep {
				SubStep::ActionSequence(list) => {
					assert_eq!(list.len(),8);
					for a in list { assert_eq!(a.get_tpv(),&false); }
				},
				_ => (),
			}
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_verification_methods() {
		let file_name = "test_verification_methods.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_verification_methods());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),5);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() { match substep { SubStep::Verification(req) => match req.get_method().as_str() { "Analysis" => (), _ => assert!(1==0), }, _ => assert!(1==0),};}
		for substep in process.get_all_sections()[0].get_all_steps()[1].get_all_sub_steps() { match substep { SubStep::Verification(req) => match req.get_method().as_str() { "Inspection" => (), _ => assert!(1==0), }, _ => assert!(1==0),};}
		for substep in process.get_all_sections()[0].get_all_steps()[2].get_all_sub_steps() { match substep { SubStep::Verification(req) => match req.get_method().as_str() { "Test" => (), _ => assert!(1==0), }, _ => assert!(1==0),};}
		for substep in process.get_all_sections()[0].get_all_steps()[3].get_all_sub_steps() { match substep { SubStep::Verification(req) => match req.get_method().as_str() { "Sampling" => (), _ => assert!(1==0), }, _ => assert!(1==0),};}
		for substep in process.get_all_sections()[0].get_all_steps()[4].get_all_sub_steps() { match substep { SubStep::Verification(req) => match req.get_method().as_str() { "Demonstration" => (), _ => assert!(1==0), }, _ => assert!(1==0),};}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_image_lines() {
		let file_name = "test_image_lines.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_image_lines());
		let process = read_ebml(&file_name);
		// SubStep::Image("../assets/placeholderImage-small.png".to_string(),"../assets/placeholderImage-small.png".to_string())
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),3);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),5);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[1].get_all_sub_steps().len(),5);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[2].get_all_sub_steps().len(),5);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() { 
			match substep {
				SubStep::Image(f,c) => {
					match f.as_str() {"filename.ext" => (), _ => assert!(1==0),};
					match c.as_str() {"Caption" => (), _ => assert!(1==0),};
				},
				_ => assert!(1==0),
			};
		};
		for substep in process.get_all_sections()[0].get_all_steps()[1].get_all_sub_steps() { 
			match substep {
				SubStep::Image(f,c) => {
					match f.as_str() {"../assets/placeholderImage-small.png" => (), _ => assert!(1==0),};
					match c.as_str() {"../assets/placeholderImage-small.png" => (), _ => assert!(1==0),};
				},
				_ => assert!(1==0),
			};
		};
		for substep in process.get_all_sections()[0].get_all_steps()[2].get_all_sub_steps() { 
			match substep {
				SubStep::Image(f,c) => {
					match f.as_str() {"../assets/placeholderImage-small.png" => (), _ => assert!(1==0),};
					match c.as_str() {"../assets/placeholderImage-small.png" => (), _ => assert!(1==0),};
				},
				_ => assert!(1==0),
			};
		};
		
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_resource_lines() {
		let file_name = "test_resource_lines.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_resources());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),2);
		let mut count_one_point_one = 0;
		let mut count_one_point_two = 0;
		for (resource,stepno) in process.get_all_resources() {
			match stepno.as_str() {
				"Step 1.1"	=> {
					count_one_point_one +=1;
					assert_eq!(resource.get_name().as_str(),"Nominal");
				},
				"Step 1.2"	=> {
					count_one_point_two +=1;
					assert_eq!(resource.get_name().as_str(),"ERROR: NO RESOURCE IDENTIFIED");
				},
				_ 			=> assert!(1==0),
			};
		}
		assert_eq!(count_one_point_one,5);
		assert_eq!(count_one_point_two,5);

		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_resources().len(),5);
		for resource in process.get_all_sections()[0].get_all_steps()[0].get_resources() {
			assert_eq!(resource.get_name().as_str(),"Nominal");
		}
		assert_eq!(process.get_all_sections()[0].get_all_steps()[1].get_resources().len(),5);
		for resource in process.get_all_sections()[0].get_all_steps()[1].get_resources() {
			assert_eq!(resource.get_name().as_str(),"ERROR: NO RESOURCE IDENTIFIED");
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_calibrated_resource_lines() {
		let file_name = "test_calibrated_resource_lines.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_calibrated_resources());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_resources().len(),21);
		assert_eq!(process.get_all_calibrated_resources().len(),20);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_get_all_commands_count() {
		let file_name = "test_get_all_commands_count.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_section_and_step_triggers());
		let process = read_ebml(&file_name);
		// SHOULD BE: Three Sections, each with three Steps, and a total of 9 command lines
		assert_eq!(process.get_all_command_lines().len(),9);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_csv_table_embedded_1000_rows() {
		let file_name = "test_csv_table_embedded_1000_rows.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_csv_table_embedded_1000_rows());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),1);
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,1000);
		assert_eq!(cols,10);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_csv_table_embedded_data_rows_wrong_lengths() {
		let file_name = "test_csv_table_embedded_rows_wrong_lengths.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_csv_table_embedded_rows_wrong_lengths());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),1);
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,15);
		assert_eq!(cols,10);
		assert_eq!(table.get_row(1)[9],"".to_string());
		assert_eq!(table.get_row(9)[1],"".to_string());
		assert_eq!(table.get_row(14)[9],"Ten".to_string());
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_csv_table_embedded_edge_cases() {
		let file_name = "test_csv_table_embedded_edge_cases.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_csv_table_embedded_edge_cases());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),9);
		
		// First table: 
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,5);
		assert_eq!(cols,3);
		
		// Second table: 
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[1] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,0);
		assert_eq!(cols,0);

		// Seventh table: 
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[6] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,8);
		assert_eq!(cols,1);
		assert_eq!(table.get_caption(),"Caption text");

		// Ninth SubStep is the Eighth table...: 
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[8] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,8);
		assert_eq!(cols,14);
		assert_eq!(table.get_caption(),"Caption text");
		assert_eq!(table.get_row(3)[4],"CUCU".to_string());
		assert_eq!(table.get_row(0)[0],"".to_string());

		destroy_test_file(&file_name);
	}

	#[test]
	fn test_csv_table_embedded_no_end_line() {
		let file_name = "test_csv_table_embedded_no_end_line.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_csv_table_embedded_no_end_line());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		// The number of SubSteps is tricky here... if working as expected, we should have:
		// > ONE Table as the first SubStep
		// > Three Warning SubSteps
		// So four SubSteps total...
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),4);
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		// The number of rows in this ONE table is tricky... because the user looks like they wanted two tables, with three warnings in between.
		// If working as expected, we should have:
		// > 5 intended CSV rows
		// > 3 Warning rows that are unintentionally read in as CSV rows because the CSV End is missing
		// > 1 CSV Start line following the warnings, read in as CSV unintentionally
		// > 5 intended CSV rows, but intended for a second table
		// So 14 rows, even though 5 are intended. The table should be read even though there is NO ending line in the file at all...
		assert_eq!(rows,14);
		assert_eq!(cols,10);
		destroy_test_file(&file_name);		
	}

	#[test]
	fn test_csv_table_embedded_no_start_line() {
		let file_name = "test_csv_table_embedded_no_start_line.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_csv_table_embedded_no_start_line());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		// The number of SubSteps is tricky here... if working as expected, we should have:
		// > ZERO tables...
		// > ONE Context
		// > ONE Warning
		// So two SubSteps, but neither of them should be Table
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),2);
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] { SubStep::Context(_) => true, _ => false, });
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[1] { SubStep::Warning(_) => true, _ => false, });
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_csv_table_external() {
		let file_name_ebml = "././test_csv_table_external.ebml".to_string();
		create_test_file(&file_name_ebml,generate_ebml_with_csv_table_external());
		
		let file_name_csv = "././test.csv".to_string();
		create_test_file(&file_name_csv,generate_csv_table_external());		

		let process = read_ebml(&file_name_ebml);
		
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),4);
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[1] { SubStep::Warning(_) => true, _ => false, });
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[2] { SubStep::Warning(_) => true, _ => false, });
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[3] { SubStep::Warning(_) => true, _ => false, });
		
		destroy_test_file(&file_name_ebml);
		destroy_test_file(&file_name_csv);
	}

	#[test]
	fn test_csv_table_external_stressing() {
		let file_name_ebml = "././test_csv_table_external_stressing.ebml".to_string();
		create_test_file(&file_name_ebml,generate_ebml_with_csv_table_external_stressing());
		
		let file_name_csv = "././test.csv".to_string();
		create_test_file(&file_name_csv,generate_csv_table_external());		

		let process = read_ebml(&file_name_ebml);

		// Running totals:
		// One Section
		// One Step
		// Seven SubSteps, all tables
		// > 0-4 : (4,3)
		// > 5   : (3,10)
		// > 6   : (4,3)
		assert_eq!(process.get_all_sections().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),1);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),7);

		// 0
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);

		// 1
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[1] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[1] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);

		// 2
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[2] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[2] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);

		// 3
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[3] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[3] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);

		// 4
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[4] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[4] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);

		// 5
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[5] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[5] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,3);
		assert_eq!(cols,10);

		// 6
		assert!(match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[6] { SubStep::Table(_) => true, _ => false, });
		let table:&Table = match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[6] {
			SubStep::Table(table) => table,
			_ => &Table::new(),
		};
		let (rows,cols) = table.get_size();
		assert_eq!(rows,4);
		assert_eq!(cols,3);

		destroy_test_file(&file_name_ebml);
		destroy_test_file(&file_name_csv);
	}

	// helper functions to generate ebml for new aliases added >0.80.0

	fn generate_ebml_with_section_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|Old-style Section".to_string());
		new_vec_of_strings.push("SEC|Alias Section".to_string());
		new_vec_of_strings.push(" s e c |Alias Section".to_string());
		new_vec_of_strings.push(" SE   c|Alias Section".to_string());
		return new_vec_of_strings;
		// 4 sections (1 old-style, 3 new alias)
	}

	fn generate_ebml_with_section_reference_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section Reference|Old-style Section Reference|Section Title".to_string());
		new_vec_of_strings.push("SECREF|Alias Section|Section Title".to_string());
		new_vec_of_strings.push(" s e c r e f |Alias Section|Section Title".to_string());
		new_vec_of_strings.push(" SE   c   RE   f   |      Alias Section     | Section Title".to_string());
		return new_vec_of_strings;
		// 4 sections references (1 old-style, 3 new alias)
	}

	fn generate_ebml_with_step_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|Old-style Step".to_string());
		new_vec_of_strings.push("STP|Alias Step".to_string());
		new_vec_of_strings.push(" s t p |Alias Step".to_string());
		new_vec_of_strings.push(" ST    p|Alias Step".to_string());
		return new_vec_of_strings;
		// 1 section, 4 steps (1 old-style, 3 new alias)
	}

	fn generate_ebml_with_context_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Context|Old-style Context".to_string());
		new_vec_of_strings.push("Comment|Alias Context".to_string());
		new_vec_of_strings.push(" c o m m e n t |Alias Context".to_string());
		new_vec_of_strings.push("TXT|Alias Context".to_string());
		new_vec_of_strings.push(" t x t |Alias Context".to_string());
		new_vec_of_strings.push("CMT|Alias Context".to_string());
		new_vec_of_strings.push(" c m t |Alias Context".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 7 substeps that are all Context (1 old-style, 6 new alias)
	}

	fn generate_ebml_with_command_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Command|Old-style Command".to_string());
		new_vec_of_strings.push("CMD|Alias Command".to_string());
		new_vec_of_strings.push(" c m d |Alias Command".to_string());
		new_vec_of_strings.push(" > |Alias Command".to_string());
		new_vec_of_strings.push("    %     |Alias Command".to_string());
		new_vec_of_strings.push("  $    |Alias Command".to_string());
		new_vec_of_strings.push("#    |Alias Command".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 7 substeps that are all Command (1 old-style, 6 new alias)
	}

	fn generate_ebml_with_image_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Image|Old-style Image filename|Old-style Image caption".to_string());
		new_vec_of_strings.push("IMG|Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push(" i m g |Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push("PICTURE|Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push(" p i c t u r e |Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push("PIC|Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push(" p i c |Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push("FIGURE|Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push(" f i g u r e |Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push("FIG|Alias Image filename|Alias Image caption".to_string());
		new_vec_of_strings.push(" f i g |Alias Image filename|Alias Image caption".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 11 substeps that are all Image (1 old-style, 10 new alias)
	}

	fn generate_ebml_with_action_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Action|Old-style Action|Old-style Expectation|Old-style TPV".to_string());
		new_vec_of_strings.push("DO|Alias Action|Alias Expectation|Alias TPV".to_string());
		new_vec_of_strings.push(" d o |Alias Action|Alias Expectation|Alias TPV".to_string());
		new_vec_of_strings.push("  D    o |Alias Action|Alias Expectation|Alias TPV".to_string());
		new_vec_of_strings.push(" dO |Alias Action|Alias Expectation|Alias TPV".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 1 substep that is an ActionSequence of length 5 (1 old-style, 4 new alias)
	}

	fn generate_ebml_with_warning_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Warning|Old-style Warning".to_string());
		new_vec_of_strings.push("WARN|Alias Warning".to_string());
		new_vec_of_strings.push(" w a r n |Alias Warning".to_string());
		new_vec_of_strings.push("WRN|Alias Warning".to_string());
		new_vec_of_strings.push(" w r n |Alias Warning".to_string());
		new_vec_of_strings.push("WAR|Alias Warning".to_string());
		new_vec_of_strings.push(" w a r |Alias Warning".to_string());
		new_vec_of_strings.push("ALERT|Alias Warning".to_string());
		new_vec_of_strings.push(" a l e r t |Alias Warning".to_string());
		new_vec_of_strings.push("  !  |Alias Warning".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 10 substeps that are all Warnings (1 old-style, 9 new alias)
	}

	fn generate_ebml_with_verification_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Verification|Old-style Verification ReqID|Old-style Verification Text|Method".to_string());
		new_vec_of_strings.push("VER|Alias Verification ReqID|Alias Verification Text|Method".to_string());
		new_vec_of_strings.push(" v e r |Alias Verification ReqID|Alias Verification Text|Method".to_string());
		new_vec_of_strings.push("REQUIREMENT|Alias Verification ReqID|Alias Verification Text|Method".to_string());
		new_vec_of_strings.push(" r e q u i r e m e n t |Alias Verification ReqID|Alias Verification Text|Method".to_string());
		new_vec_of_strings.push("REQ|Alias Verification ReqID|Alias Verification Text|Method".to_string());
		new_vec_of_strings.push(" r e q |Alias Verification ReqID|Alias Verification Text|Method".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 7 substeps that are all Verifications (1 old-style, 6 new alias)
	}

	fn generate_ebml_with_resource_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Resource|Old-style Resource|Old-style Calibration".to_string());
		new_vec_of_strings.push("RES|Alias Resource|Alias Calibration".to_string());
		new_vec_of_strings.push(" r e s |Alias Resource|Alias Calibration".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 3 substeps that are all Resources (1 old-style, 2 new alias)
	}

	fn generate_ebml_with_objective_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Objective|Old-style Objective".to_string());
		new_vec_of_strings.push("OBJ|Alias Objective".to_string());
		new_vec_of_strings.push(" o b j |Alias Objective".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 3 substeps that are all Objectives (1 old-style, 2 new alias)
	}

	fn generate_ebml_with_out_of_scope_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		new_vec_of_strings.push("Out of Scope|Old-style Out of Scope".to_string());
		new_vec_of_strings.push("OOS|Alias Objective".to_string());
		new_vec_of_strings.push(" o o s |Alias Out of Scope".to_string());
		return new_vec_of_strings;
		// 1 section, 1 step, 3 substeps that are all Out of Scopes (1 old-style, 2 new alias)
	}

	fn generate_ebml_with_revision_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push(" Revision |      Successful Revision      |    Successful Description       ".to_string());
		new_vec_of_strings.push(" REV |      Successful Revision      |    Successful Description       ".to_string());
		new_vec_of_strings.push(" r e v |      Successful Revision      |    Successful Description       ".to_string());
		new_vec_of_strings.push("Section|One section".to_string());
		new_vec_of_strings.push("Step|One step".to_string());
		return new_vec_of_strings;
		// 3 Revisions, each of which should be Rev "Successful Revision" with reason of "Successful Description"
	}

	fn generate_ebml_with_template_alias() -> Vec<String> {
		let mut new_vec_of_strings:Vec<String> = vec![];
		new_vec_of_strings.push("Template | Nominal.css".to_string());
		new_vec_of_strings.push("CSS|Alias.css".to_string());
		new_vec_of_strings.push(" c s s |Alias.css".to_string());
		return new_vec_of_strings;
		// 3 Templates, one old-style and 2 alias
	}

	// use the helper functions, and confirm that EBML intent is read correctly

	#[test]
	fn test_section_alias() {
		let file_name = "test_section_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_section_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections().len(),4);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_step_alias() {
		let file_name = "test_step_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_step_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps().len(),4);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_context_alias() {
		let file_name = "test_context_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_context_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),7);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Context(..) => println!(">>Context line found, as expected!"), _ => panic!(">>Should be a 'Context'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_command_alias() {
		let file_name = "test_command_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_command_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),7);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Command(..) => println!(">>Command line found, as expected!"), _ => panic!(">>Should be a 'Command'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_image_alias() {
		let file_name = "test_image_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_image_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),11);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Image(..) => println!(">>Image line found, as expected!"), _ => panic!(">>Should be a 'Image'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_action_alias() {
		let file_name = "test_action_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_action_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),1);
		match &process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps()[0] {
			SubStep::ActionSequence(list) => assert_eq!(list.len(),5),
			_ => panic!(">>Should be a 'ActionSequence'"),
		};
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_warning_alias() {
		let file_name = "test_warning_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_warning_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),10);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Warning(..) => println!(">>Warning line found, as expected!"), _ => panic!(">>Should be a 'Warning'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_verification_alias() {
		let file_name = "test_verification_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_verification_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),7);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Verification(..) => println!(">>Verification line found, as expected!"), _ => panic!(">>Should be a 'Verification'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_resource_alias() {
		let file_name = "test_resource_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_resource_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),3);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Resource(..) => println!(">>Resource line found, as expected!"), _ => panic!(">>Should be a 'Resource'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_objective_alias() {
		let file_name = "test_objective_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_objective_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),3);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::Objective(..) => println!(">>Objective line found, as expected!"), _ => panic!(">>Should be a 'Objective'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_out_of_scope_alias() {
		let file_name = "test_out_of_scope_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_out_of_scope_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps().len(),3);
		for substep in process.get_all_sections()[0].get_all_steps()[0].get_all_sub_steps() {
			match substep { SubStep::OutOfScope(..) => println!(">>Out of Scope line found, as expected!"), _ => panic!(">>Should be a 'Out of Scope'")};
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_revision_alias() {
		let file_name = "test_revision_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_revision_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_revisions().len(),3);
		for (rev,desc) in process.get_all_revisions() {
			assert_eq!(rev,"Successful Revision");
			assert_eq!(desc,"Successful Description");
		}
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_template_alias() {
		let file_name = "test_template_alias.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_template_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_templates().len(),3);
		destroy_test_file(&file_name);
	}

	// for stanhope features added between 0.95.0 and 0.103.0

	#[test]
	fn test_process_get_step_count() {
		let file_name = "test_process_get_step_count.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_1000_steps_in_one_section());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_step_count(),1000);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_process_get_all_context_lines() {
		let file_name = "test_process_get_all_context_lines.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_context_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_context_lines().len(),7);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_process_get_all_images() {
		let file_name = "test_process_get_all_images.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_image_lines());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_all_images().len(),15);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_process_get_unique_image_count() {
		let file_name = "test_process_get_unique_image_count.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_image_lines());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_unique_image_count(),2);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_process_get_missing_image_count() {
		let file_name = "test_process_get_missing_image_count.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_diabolical_image_lines());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_missing_image_count(),2);
		assert_eq!(process.get_missing_images().len(),2);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_process_get_section_reference_count() {
		let file_name = "test_process_get_section_reference_count.ebml".to_string();
		create_test_file(&file_name,generate_ebml_with_section_reference_alias());
		let process = read_ebml(&file_name);
		assert_eq!(process.get_section_reference_count(),4);
		destroy_test_file(&file_name);
	}

	#[test]
	fn test_process_set_and_get_process_file() {
		let test_process_file = "Not a real EBML file";
		let mut new_proc = Process::new();
		assert_ne!(new_proc.get_process_file().to_string(),test_process_file.to_string());
		new_proc.set_process_file(test_process_file);
		assert_eq!(new_proc.get_process_file().to_string(),test_process_file.to_string());
	}

	#[test]
	fn test_process_set_and_get_full_source() {
		let test_full_source = vec!["First Line of fake EBML".to_string(),"Second Line of fake EBML".to_string()];
		let mut new_proc = Process::new();
		assert_ne!(new_proc.get_full_source(),&test_full_source);
		new_proc.set_full_source(test_full_source.clone());
		assert_eq!(new_proc.get_full_source(),&test_full_source);
	}

	#[test]
	fn test_section_set_get_relative_path() {
		let test_relative_path = "Not a real Process folder path";
		let mut new_sec = Section::new();
		assert_ne!(new_sec.get_relative_path().to_string(),test_relative_path.to_string());
		new_sec.set_relative_path(test_relative_path);
		assert_eq!(new_sec.get_relative_path().to_string(),test_relative_path.to_string());
	}

}