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.

//  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄         ▄  ▄▄▄▄▄▄▄▄▄▄▄  ▄▄▄▄▄▄▄▄▄▄▄ 
// ▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌
// ▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀█░█▀▀▀▀ ▐░█▀▀▀▀▀▀▀█░▌▐░▌       ▐░▌▐░█▀▀▀▀▀▀▀▀▀  ▀▀▀▀█░█▀▀▀▀ 
// ▐░▌               ▐░▌     ▐░▌       ▐░▌▐░▌       ▐░▌▐░▌               ▐░▌     
// ▐░█▄▄▄▄▄▄▄▄▄      ▐░▌     ▐░█▄▄▄▄▄▄▄█░▌▐░▌       ▐░▌▐░▌               ▐░▌     
// ▐░░░░░░░░░░░▌     ▐░▌     ▐░░░░░░░░░░░▌▐░▌       ▐░▌▐░▌               ▐░▌     
//  ▀▀▀▀▀▀▀▀▀█░▌     ▐░▌     ▐░█▀▀▀▀█░█▀▀ ▐░▌       ▐░▌▐░▌               ▐░▌     
//           ▐░▌     ▐░▌     ▐░▌     ▐░▌  ▐░▌       ▐░▌▐░▌               ▐░▌     
//  ▄▄▄▄▄▄▄▄▄█░▌     ▐░▌     ▐░▌      ▐░▌ ▐░█▄▄▄▄▄▄▄█░▌▐░█▄▄▄▄▄▄▄▄▄      ▐░▌     
// ▐░░░░░░░░░░░▌     ▐░▌     ▐░▌       ▐░▌▐░░░░░░░░░░░▌▐░░░░░░░░░░░▌     ▐░▌     
//  ▀▀▀▀▀▀▀▀▀▀▀       ▀       ▀         ▀  ▀▀▀▀▀▀▀▀▀▀▀  ▀▀▀▀▀▀▀▀▀▀▀       ▀      
                                                                              
/// **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 {

	/// 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>,
}

/// 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>,
}

/// 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 {

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

	// 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");

	// 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" 		=> 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" 		=> 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" 		=> {
				new_proc.add_section(extract_next_section(&lines[ii..lines.len()],&file_name));
				sec_cnt += 1;
				stp_cnt = 0;
			},
			"STEP"		 	=> {
				stp_cnt += 1;
				//println!("Step {}.{}",sec_cnt,stp_cnt);
			}
			"ACTION"	 	=> (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"COMMAND" 		=> (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"CONTEXT"		=> (), 
			"IMAGE"		 	=> (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"WARNING"		=> (), //println!("Valid \"{}\", skipping...",&line[0..index]),
			"CSVSTART"		=> (),
			"CSVEND"		=> (),
			"CSVFILE"		=> (),
			"VERIFICATION"	=> new_proc.add_verification(parse_verification_line(remainder),"Step ".to_string()+&sec_cnt.to_string()+"."+&stp_cnt.to_string()),
			"RESOURCE"		=> {
				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"		=> new_proc.add_objective(remainder.to_string(),"Step ".to_string()+&sec_cnt.to_string()+"."+&stp_cnt.to_string()),
			"OUTOFSCOPE"	=> 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" => { 
				section_count +=1;
				if section_count > 1 { break 'one_section };
				new_section.set_title(remainder);
				},
			"STEP" => 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

}

/// 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" => { 
				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" => {
				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" => {
				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" => {
				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" => {
				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" => {
				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" => {
				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" => {
				new_step.add_sub_step(SubStep::Objective(remainder.to_string()));
				allow_action = true;
				},
			// "Out of Scope" is another simple line of text
			"OUTOFSCOPE" => {
				new_step.add_sub_step(SubStep::OutOfScope(remainder.to_string()));
				allow_action = true;
				},
			// Context is another simple line of text
			"CONTEXT" => {
				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" => 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>> {
		use std::{
			fs::File,
			io::{self, BufRead, BufReader},
			path::Path,
		};

		// 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![];
		}

		// 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()
		}

		// 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 line below, because it's built on an unstable house of cards
	let path_parts = ebml_file.split('/').collect::<Vec<_>>();
	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);
	
	// 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" => 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(),all_parts[0].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());
				}
			} else {
				if all_parts[1]=="" {
					return SubStep::Image(all_parts[0].to_string(),all_parts[0].to_string())
				} else {
					return SubStep::Image(all_parts[0].to_string(),all_parts[1].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 { 
			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: "NO SUBJECT IN EBML FILE".to_string(),
			subject_image: "DEFAULT-PLACEHOLDER-IMAGE.png".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![],
		}
	}

	/// 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 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
	}

	/// Used in verbose mode to display contents of the struct to stdout
	pub fn display_process_to_stdout(&self) {
		println!("==============================================================");
		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!(" ↪ Author of this Rev:       {}",&self.get_author());
		println!(" ↪ Reviewer of this Rev:     {}",&self.get_reviewer());
		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!(" ↪ Count of Sections:        {}",&self.get_all_sections().len());
		println!(" ↪ Count of Resources:       {}",&self.get_all_resources().len());
		println!(" ↪ Count of Verifications:   {}",&self.get_all_verifications().len());
		println!(" ↪ Count of Templates:       {}",&self.get_all_templates().len());
		println!(" ↪ Count of TPV Actions:     {}",&self.get_tpv_count());
		println!(" ↪ Count of Non-TPV Actions: {}",&self.get_non_tpv_count());
		println!("==============================================================");
	}

	/// 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); }
	}
	
}

/// 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![],
		}
	}

	/// 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 }

	/// 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);
	}
}

/// 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,
			1 => self.array[0].len(),
			_ => self.array[0].len(), // TODO
		};
		
		(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![],});
		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);
	}

}