<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">\documentclass[12pt, titlepage]{article}

\usepackage{booktabs}
\usepackage{tabularx}
\usepackage{hyperref}
\hypersetup{
    colorlinks,
    citecolor=black,
    filecolor=black,
    linkcolor=red,
    urlcolor=blue
}
\usepackage[round]{natbib}

\title{SE 3XA3: Test Plan\\Gifitti}

\author{Team \#2,Gifitti
		\\ Nicolai Kozel kozeln
		\\ Riley McGee mcgeer
		\\ Student 3 name and macid
}

\date{\today}

\input{../Comments}

\begin{document}

\maketitle

\pagenumbering{roman}
\tableofcontents
\listoftables
\listoffigures

\begin{table}[bp]
\caption{\bf Revision History}
\begin{tabularx}{\textwidth}{p{3cm}p{2cm}X}
\toprule {\bf Date} &amp; {\bf Version} &amp; {\bf Notes}\\
\midrule
Date 1 &amp; 1.0 &amp; Notes\\
Date 2 &amp; 1.1 &amp; Notes\\
\bottomrule
\end{tabularx}
\end{table}

\newpage

\pagenumbering{arabic}

This document describes the test plan for the Gifitti application developed for 3XA3 at McMaster University.  

\section{General Information}

\subsection{Purpose}

\subsection{Scope}

\subsection{Acronyms, Abbreviations, and Symbols}
	
\begin{table}[hbp]
\caption{\textbf{Table of Abbreviations}} \label{Table}

\begin{tabularx}{\textwidth}{p{3cm}X}
\toprule
\textbf{Abbreviation} &amp; \textbf{Definition} \\
\midrule
Abbreviation1 &amp; Definition1\\
Abbreviation2 &amp; Definition2\\
\bottomrule
\end{tabularx}

\end{table}

\begin{table}[!htbp]
\caption{\textbf{Table of Definitions}} \label{Table}

\begin{tabularx}{\textwidth}{p{3cm}X}
\toprule
\textbf{Term} &amp; \textbf{Definition}\\
\midrule
Term1 &amp; Definition1\\
Term2 &amp; Definition2\\
\bottomrule
\end{tabularx}

\end{table}	

\subsection{Overview of Document}

\section{Plan}
	
\subsection{Software Description}

\subsection{Test Team}

\subsection{Automated Testing Approach}

\subsection{Testing Tools}

\subsection{Testing Schedule}
		
See Gantt Chart at the following url ...

\section{System Test Description}
	
\subsection{Tests for Functional Requirements}

\subsubsection{Open GIF}
		
\paragraph{The User is Able to Open a GIF from a specified location}

\begin{enumerate}

\item{Select proper formatted gif- id1\\}

Type: Manual Functional.
Initial State: Program loaded; no GIF Loaded.
Input: File name.
Output: System loads gif into memory, displays it to the user in the gif view.
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Select Open}
\item{From the Open dialog specify a path to a known gif image}
\item{After the image is loaded verify that it is being displayed, and resides in system memory}
\\
\end{enumerate}			
\item{No File Selected in File Dialog-id2\\}

Type: Manual Functional.
Initial State: Program loaded; no GIF Loaded.
Input: No file path.
Output: No image loaded.
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Select Open}
\item{Select open option with no file path specified}
\item{Verify program remains open, and no image is loaded}
\\
\end{enumerate}	
\item{Close File Dialog-id3\\}

Type: Manual Functional.
Initial State: Program loaded; no GIF Loaded.
Input: None.
Output: No image loaded.
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Select Open}
\item{Close the file dialog}
\item{Verify program remains open, and no image is loaded}
\\
\end{enumerate}
\item{Open random non gif file-id4\\}

Type: Manual Functional.
Initial State: Program loaded; no GIF Loaded.
Input: File that is not a GIF.
Output: No image loaded.
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Select Open}
\item{Try and select a file that is not a GIF or specify a file path to a known file}
\item{Verify program remains open, and no image is loaded}
\\
\end{enumerate}
%
%End of Open Requirement

\end{enumerate}

\subsubsection{Save GIF}
\paragraph{The user is able to save a GIF to a specified location}

\begin{enumerate}

\item{Save GIF to known location-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: File path, GIF file.\\
Output: GIF file saved to specified location.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a  GIF}
\item{Select save as}
\item{Specify a known system file path and a saved image name}
\item{Verfify the loaded and saved GIFs are identical}
\\
\end{enumerate}	

\item{Save GIF to no existant location- id2\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: File path, GIF file.\\
Output: GIF file not saved to specified location.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a  GIF}
\item{Select save as}
\item{Specify a system file path known not to exist and a saved image name}
\item{Verify the user is informed that the file path does not work}
\\
\end{enumerate}	
\item{Save GIF to Opened Location- id3\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: File path, GIF file.\\
Output: GIF file saved to specified location.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a  GIF}
\item{Modify the GIF}
\item{Save image}
\item{Verify new GIF is saved over the originally opened GIF}
\\
\end{enumerate}	
%
%End of save Requirement
\end{enumerate} 

\subsubsection{Save GIF as Sprite Spreadsheet}
\paragraph{The user is able to save a GIF as a sprite spreadsheet in a specified location}

\begin{enumerate}
\item{Save Sprite Spreadsheet to known location-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: File path, GIF file.\\
Output: GIF file saved as a Sprite Spreadsheet to specified location.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a GIF}
\item{Choose to export the image as a sprite spreadsheet}
\item{Verify that the GIF is a single image representation of the GIF via frames}
\\
\end{enumerate}	
%
%End of Sprite Spreadsheet Requirement
\end{enumerate} 

\subsubsection{GIF Start, Stop, Modify Length}
\paragraph{The user is able to start (play), start and stop GIFs, testing of GIF shortening and playback speed occurs here as well}

\begin{enumerate}
\item{Play Stop GIF-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: GIF\\
Output: None.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a GIF}
\item{Select Play Option}
\item{Verify the Gif is iterating over frames as expected}
\item{Select Play option again, verify no change occurs}
\item{Select Stop}
\item{Verifiy GIF stops playing}
\item{Select Stop again, verify no change occurs}
\\
\end{enumerate}

\item{GIF shorten-id2\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: GIF\\
Output: Shortend GIF.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a GIF}
\item{Shorten gif frames in use}
\item{Play the GIF to verify it is correct}
\item{Export the GIF}
\item{Verify that the exported GIF represents the one playing, and is shorter than the original}
\\
\end{enumerate}		

\item{GIF speed-id3\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: GIF\\
Output: GIF inputted with different frame rate.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a GIF}
\item{Increase frame hold time}
\item{Play the GIF to verify it is slower than original}
\item{Export the GIF}
\item{Verify that the exported GIF represents the one playing, and is slower, with respect to frame rate, than the original}
\\
\end{enumerate}	
%
%End of GIF Start, Stop, Modify Length Requirement
\end{enumerate} 

\subsubsection{Save all frames in a GIF to another known format}
\paragraph{The user is able to save a GIF frame by frame to PNG, JPEF, BMP and TIFF formats}

\begin{enumerate}
\item{Save PNG frames to known location-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF Loaded.\\
Input: Folder path, GIF file.\\
Output: PNG Frames in specified folder named corresponding to frame.\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Open a GIF}
\item{Choose to export the image as a PNG set}
\item{Select the folder where the PNGs will be dumped}\
\item{Verify the folder fills with frames as PNG}
\item{Ensure a 3rd party program can load the PNGs. Software such as Photoshop or MS paint is satisfactory}
\\
\end{enumerate}	

\item{Save JPEG frames to known location-id2\\}
This test is identical to id1 with PNG replaced with JPEG

\item{Save BMP frames to known location-id3\\}
This test is identical to id1 with PNG replaced with BMP

\item{Save TIFF frames to known location-id4\\}
This test is identical to id1 with PNG replaced with TIFF
\end{enumerate}	
%
%End of Save all frames in a GIF to another known format Requirement

\subsubsection{Help Context}
\paragraph{Verifies and validates HELP context}

\begin{enumerate}
\item{Help Context-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded\\
Input: None\\
Output: None\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Select Help Context}
\item{Reccurse through all Help Context options, verifiy spelling for professionality}
\item{Close help context, verify program remains in same state as launch put it in}
\\
\end{enumerate}	
%
%End of Help Requirement
\end{enumerate}


\subsubsection{GIF reset}
\paragraph{Verifies and validates GIF can be reset to loaded state}

\begin{enumerate}
\item{Modify Attributes-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF loaded\\
Input: GIF\\
Output: Inputted GIF\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a GIF}
\item{Modify GIF attributes such as frame length, coloration etc}
\item{Select reset}
\item{Verify GIF in is the same as current GIF shown}
\\
\end{enumerate}	

\item{Modify via adding a frame-id2\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF loaded\\
Input: GIF, inputted frame\\
Output: Inputted GIF\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a GIF}
\item{Modify GIF by adding a frame}
\item{Select reset}
\item{Verify GIF loaded has added frame removed}
\\
\end{enumerate}	

\item{Modify via frame subset selected-id3\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF loaded\\
Input: GIF\\
Output: Inputted GIF\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a GIF}
\item{Modify GIF by subsetting what frames are used}
\item{Select reset}
\item{Verify GIF loaded returns to full GIF state}
\\
\end{enumerate}

%
%End of Reset Requirement
\end{enumerate}


\subsubsection{Frame Addition}
\paragraph{Verifies frame addition}

\begin{enumerate}
\item{Add GIFs-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded\\
Input: GIF x 2\\
Output: Concatinated GIFs\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a Gif}
\item{Select a frame and import a gif}
\item{Gif should subset from frame to end of the imported gif}
\item{Verify the concatination holds on export}
\\
\end{enumerate}	

\item{Add PNGs-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded\\
Input: GIF; PNG image\\
Output: GIF with PNG input added as a frame\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a Gif}
\item{Select a frame and import a PNG}
\item{Verify PNG is added after current frame in GIF}
\item{Verify the the new GIF is exported the same way}
\end{enumerate}
\item{JPEG frames to GIF-id2\\}
This test is identical to id2 with PNG replaced with JPEG

\item{TIFF frames to GIF-id3\\}
This test is identical to id2 with PNG replaced with TIFF

\item{BMP frames to GIF-id4\\}
This test is identical to id2 with PNG replaced with BMP
%
%End of Frame Addition Requirement
\end{enumerate}

\subsubsection{Frame Drawing}
\paragraph{Verifies and validates ability to draw on frames}

\begin{enumerate}
\item{Single Frame Drawing-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF loaded\\
Input: GIF\\
Output: Inputted Gif with image overlay on a frame\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a GIF}
\item{Make an obvious edit to a frame via drawing}
\item{Export the GIF and verify obvious change remains}
\\
\end{enumerate}	
\item{Multi Frame Drawing-id1\\}

Type: Manual Functional.\\
Initial State: Program loaded; GIF loaded\\
Input: GIF\\
Output: Inputted Gif with image overlay many frames\\
	
How test will be performed: 
\begin{enumerate}
\item{Launch the program}
\item{Load a GIF}
\item{Make an obvious edit to a frame via drawing}
\item{Make the edit extend over a set of frames}
\item{Export the GIF and verify obvious change remains on all selected frames}
\\
\end{enumerate}	
%
%End of Frame Drawing Requirement
\end{enumerate}

\subsection{Tests for Nonfunctional Requirements}

\subsubsection{Area of Testing1}
		
\paragraph{Title for Test}

\begin{enumerate}

\item{test-id1\\}

Type: 
					
Initial State: 
					
Input/Condition: 
					
Output/Result: 
					
How test will be performed: 
					
\item{test-id2\\}

Type: Functional, Dynamic, Manual, Static etc.
					
Initial State: 
					
Input: 
					
Output: 
					
How test will be performed: 

\end{enumerate}

\subsubsection{Area of Testing2}

...

\section{Tests for Proof of Concept}

\subsection{Opening a GIF file for playback}
		
\paragraph{Open GIF}

\begin{enumerate}

\item{OpenGif-01\\}

Type: Manual Functional 
					
Initial State: Program must be in normal state (form window is open and playback window is blank).
					
Input: File 
					
Output: GIF is shown in playback window of the form. 
					
How test will be performed: Click open button, select a file of type .gif, and verify that the GIF loads and begins to playback within the form window. 				

\end{enumerate}

\subsection{Saving a GIF file's frames}

\paragraph{Save GIF}

\begin{enumerate}

\item{SaveGif-01\\}

Type: Manual Functional 
				
Initial State: Program must be in playback state (form window is open and playback window is playing GIF).
					
Input: GIF File  
					
Output: GIF's frames are saved as .bmp in folder specified.  
					
How test will be performed: Click save frames button, select a folder, and verify that the GIF's frames are saved to the specified folder as .bmp.				

\end{enumerate}
	
\section{Comparison to Existing Implementation}	
\subsection{Graphics/UI}
\begin{enumerate}
\item GIF playback resolution is the same or better than Gif Viewer.
\item Program has the same button scheme as Gif Viewer (Open button to open file, Extract Frames button to save frames).
\item Program has a help menu available that is similiar to Gif Viewer, but is available at all times. 
\item Program's color scheme and design resembles Gif Viewer.
\end{enumerate}
\subsection{Performance}
\begin{enumerate}
\item GIF playback is at the same smoothness/framerate or better than Gif Viewer.
\item Opening and saving a file takes the same amount of time or less than Gif Viewer.
\end{enumerate}
				
\section{Unit Testing Plan}
		
\subsection{Unit testing of internal functions}
		
\subsection{Unit testing of output files}		

\bibliographystyle{plainnat}

\bibliography{SRS}

\newpage

\section{Appendix}

This section contains symbolic parameters for this document and the usability survey that will be delivered 
to a focus group upon initial completion of the application. 
\subsection{Symbolic Parameters}

The definition of the test cases will call for SYMBOLIC\_CONSTANTS.
Their values are defined in this section for easy maintenance.

\subsection{Usability Survey Questions}
The survey will be deliverered in the same format as the Questionaire for User Interface Satisfaction. This 
questionaire is composed of various questions pertaining to several sub categories on a 0-9 scale. This includes the screen,
terminology and system information, learning, and system capabilites. It also allows the user to list the most 
positive and negative aspects of the program. The questionaire can be found at \href{http://garyperlman.com/quest/quest.cgi?form=QUIS}{garyperlman.com}

\end{document}</pre></body></html>