smart_brain_test/testresults/testrun.tex

\documentclass[a4paper]{article}
%\documentclass[a4paper,landscape]{article}

\renewcommand{\familydefault}{\sfdefault}
\usepackage[table]{xcolor}
\definecolor{orange}{rgb}{1, 0.7, 0}
\definecolor{lightgrey}{rgb}{0.925, 0.925, 0.925}

\setlength{\topmargin}{-3cm}
\setlength{\oddsidemargin}{-0.5cm}
\setlength{\evensidemargin}{0cm}
\setlength{\textwidth}{17.5cm}
\setlength{\textheight}{24.5cm}
%\setlength{\textwidth}{25cm}
%\setlength{\textheight}{15cm}
\setlength{\headheight}{84pt}

\usepackage{fancyvrb}
\usepackage{fvextra}
%\usepackage{framed,color}
%\newenvironment{modulelog}{\snugshade\Verbatim}{\endVerbatim\endsnugshade}
\usepackage{adjustbox}
\newenvironment{modulelog}%
{\par\noindent\adjustbox{margin=0ex,bgcolor=shadecolor,margin=0ex}\bgroup\varwidth\linewidth\Verbatim}%
{\endVerbatim\endvarwidth\egroup}
%\usepackage{xcolor}

\renewcommand{\baselinestretch}{1,2}
\setlength{\parindent}{0pt}
\setlength{\parskip}{9pt plus3pt minus3pt}

\usepackage{listings}
\usepackage{color}
\definecolor{bg-partially-covered}{rgb}{1,1,0.6}    % light-yellow
\definecolor{bg-uncovered}{rgb}{1,0.8,0.8}          % light-red
\definecolor{bg-covered}{rgb}{0.95,1,0.95}          % very light-green
\definecolor{bg-clean}{rgb}{1,1,1}                  % white
\definecolor{mygreen}{rgb}{0,0.6,0}
\definecolor{mygray}{rgb}{0.5,0.5,0.5}
\definecolor{mymauve}{rgb}{0.58,0,0.82}
\lstset{ %
  backgroundcolor=\color{white},   % choose the background color; you must add \usepackage{color} or \usepackage{xcolor}; should come as last argument
  basicstyle=\footnotesize,        % the size of the fonts that are used for the code
  breakatwhitespace=false,         % sets if automatic breaks should only happen at whitespace
  breaklines=true,                 % sets automatic line breaking
  captionpos=b,                    % sets the caption-position to bottom
  commentstyle=\color{mygreen},    % comment style
  deletekeywords={...},            % if you want to delete keywords from the given language
  escapeinside={\%*}{*)},          % if you want to add LaTeX within your code
  extendedchars=true,              % lets you use non-ASCII characters; for 8-bits encodings only, does not work with UTF-8
  frame=none,	                   % adds a frame around the code
  keepspaces=true,                 % keeps spaces in text, useful for keeping indentation of code (possibly needs columns=flexible)
  keywordstyle=\color{blue},       % keyword style
  language=Octave,                 % the language of the code
  morekeywords={*,...},            % if you want to add more keywords to the set
  numbers=left,                    % where to put the line-numbers; possible values are (none, left, right)
  numbersep=5pt,                   % how far the line-numbers are from the code
  numberstyle=\tiny\color{mygray}, % the style that is used for the line-numbers
  rulecolor=\color{black},         % if not set, the frame-color may be changed on line-breaks within not-black text (e.g. comments (green here))
  showlines=true,
  showspaces=false,                % show spaces everywhere adding particular underscores; it overrides 'showstringspaces'
  showstringspaces=false,          % underline spaces within strings only
  showtabs=false,                  % show tabs within strings adding particular underscores
  stepnumber=1,                    % the step between two line-numbers. If it's 1, each line will be numbered
  stringstyle=\color{mymauve},     % string literal style
  tabsize=2,	                   % sets default tabsize to 2 spaces
}
\usepackage{hyperref}
\usepackage{longtable}[=v4.13]
\usepackage{tabu}
\usepackage{multicol}
\usepackage{booktabs}
\usepackage{graphicx}
\usepackage{lastpage} % for the number of the last page in the document
\usepackage{fancyhdr}

\fancyhf{}
\renewcommand{\headrulewidth}{0pt}
\renewcommand{\footrulewidth}{0pt}
\lhead{\textcolor{gray}{}}
\chead{\textcolor{gray}{ Unittest for {\tt smart\_brain }}}
\rhead{\textcolor{gray}{}}
\lfoot{\textcolor{gray}{}}
\cfoot{\textcolor{gray}{}}
\rfoot{\textcolor{gray}{\thepage\,/ \pageref{LastPage}}}

\begin{document}

\begin{titlepage}
\date{\today}
\title{
	Unittest for {\tt smart\_brain }
}
\date{\today} 
\maketitle
\thispagestyle{empty}
\newpage
\end{titlepage}

\setcounter{page}{1}
\pagestyle{fancy}

\tableofcontents
\newpage

\section{Test System Information}
\begin{tabu} to \linewidth {lX}
\toprule
{\bf System Information}   & \\
\midrule
Architecture & 64bit \\
Machine & x86\_64 \\
Hostname & ahorn \\
Distribution & Linux Mint 21.1 (vera) \\
System & Linux \\
Kernel & 5.15.0-60-generic (\#66-Ubuntu SMP Fri Jan 20 14:29:49 UTC 2023) \\
Username & dirk \\
Path & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test \\
\bottomrule
\end{tabu}

\section{Test Object Information}
\begin{tabu} to \linewidth {lX}
\toprule
{\bf Test object Information}   & \\
\midrule
Test Object Name & smart\_brain \\
Test Object Vesion & 1.2.0 \\
GIT repository & https:/\allowbreak /\allowbreak git.mount-mockery.de/\allowbreak smarthome/\allowbreak smart\_brain.git\\
GIT reference & f3ed72974e5fd3bf932ab78acdf0a1d6154dd733\\
\bottomrule
\end{tabu}


\section{Summary}
\begin{tabu} to \linewidth {lX}
	\toprule
	Number of tests & {\bf 67}\\
	Number of successfull tests & {\bf 67}\\
	Number of possibly failed tests & \textcolor{black}{\bf 0}\\
	Number of failed tests & \textcolor{black}{\bf 0}\\
	\midrule
	Executionlevel    & Full Test (all defined tests)\\
	Time consumption  & 84.664s\\
	\bottomrule
\end{tabu}






  \section{\textcolor{green}{Testcases (Success)}}
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak diningroom/\allowbreak powerplug\_floorlamp }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:23,206\\
Finished-Time: & 2023-02-15 07:13:24,415\\
Time-Consumption & 1.209s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffe/\allowbreak diningroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:24,416\\
Finished-Time: & 2023-02-15 07:13:25,627\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off synchronisation test: shellies/\allowbreak ffe/\allowbreak diningroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (24)\\
Start-Time: & 2023-02-15 07:13:25,627\\
Finished-Time: & 2023-02-15 07:13:26,532\\
Time-Consumption & 0.905s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'False'\\
\bf{\,Info } & Changing master device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak diningroom/\allowbreak powerplug\_floorlamp) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing master device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak diningroom/\allowbreak powerplug\_floorlamp) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffe/\allowbreak floor/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:26,533\\
Finished-Time: & 2023-02-15 07:13:27,743\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffe/\allowbreak kitchen/\allowbreak circulation\_pump }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:27,744\\
Finished-Time: & 2023-02-15 07:13:28,953\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffe/\allowbreak kitchen/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:28,954\\
Finished-Time: & 2023-02-15 07:13:30,164\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:13:30,165\\
Finished-Time: & 2023-02-15 07:13:31,978\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:13:31,979\\
Finished-Time: & 2023-02-15 07:13:33,792\\
Time-Consumption & 1.813s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:33,793\\
Finished-Time: & 2023-02-15 07:13:35,004\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:13:35,005\\
Finished-Time: & 2023-02-15 07:13:36,817\\
Time-Consumption & 1.812s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:13:36,818\\
Finished-Time: & 2023-02-15 07:13:38,632\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffe/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:38,632\\
Finished-Time: & 2023-02-15 07:13:39,843\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness synchronisation test: videv/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (42)\\
Start-Time: & 2023-02-15 07:13:39,844\\
Finished-Time: & 2023-02-15 07:13:41,055\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'True' (Power on)\\
\bf{\,Info } & Changing master device brightness to '35'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_2) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_3) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_4) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_5) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_6) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing master device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_2) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_3) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_4) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_5) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_6) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting preconditions for master device 'False' (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature synchronisation test: videv/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (67)\\
Start-Time: & 2023-02-15 07:13:41,056\\
Finished-Time: & 2023-02-15 07:13:42,266\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'True' (Power on)\\
\bf{\,Info } & Changing master device color temperature to '2'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_2) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_3) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_4) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_5) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_6) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing master device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_2) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_3) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_4) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_5) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_6) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting preconditions for master device 'False' (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off synchronisation test: shellies/\allowbreak ffe/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (24)\\
Start-Time: & 2023-02-15 07:13:42,267\\
Finished-Time: & 2023-02-15 07:13:43,177\\
Time-Consumption & 0.910s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'False'\\
\bf{\,Info } & Changing master device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_2) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_3) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_4) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_5) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_6) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing master device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_1) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_2) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_3) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_4) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_5) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak ffe/\allowbreak livingroom/\allowbreak floorlamp\_6) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak bed\_light\_di }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:13:43,177\\
Finished-Time: & 2023-02-15 07:13:44,990\\
Time-Consumption & 1.812s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak bed\_light\_di }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:44,990\\
Finished-Time: & 2023-02-15 07:13:46,199\\
Time-Consumption & 1.209s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak bed\_light\_ma }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:46,200\\
Finished-Time: & 2023-02-15 07:13:47,410\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Away mode test: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (101)\\
Start-Time: & 2023-02-15 07:13:47,411\\
Finished-Time: & 2023-02-15 07:13:48,318\\
Time-Consumption & 0.908s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 16.5 and Type is $<$class 'float'$>$).\\
\bf{\,Info } & Deactivating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Boost mode test: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (128)\\
Start-Time: & 2023-02-15 07:13:48,319\\
Finished-Time: & 2023-02-15 07:13:49,225\\
Time-Consumption & 0.906s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Activating boost mode\\
\bf{\,\textcolor{green}{Success} } & Boost timer is greater expectation (Content 900 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Setting postconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Default temperature test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (50)\\
Start-Time: & 2023-02-15 07:13:49,225\\
Finished-Time: & 2023-02-15 07:13:49,830\\
Time-Consumption & 0.604s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Valve setpoint to 16.5)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint (is not default temperature) is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Triggering set to default temperature (21.5)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Summer mode test: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (74)\\
Start-Time: & 2023-02-15 07:13:49,830\\
Finished-Time: & 2023-02-15 07:13:50,738\\
Time-Consumption & 0.908s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ User temperature setpoint test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (22)\\
Start-Time: & 2023-02-15 07:13:50,738\\
Finished-Time: & 2023-02-15 07:13:51,949\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Changing valve temperature setpoint to '16.5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 16.5 and Type is $<$class 'float'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 16.5 and Type is $<$class 'float'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '21.5'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bf{\,Info } & Changing valve temperature setpoint to '16.5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 16.5 and Type is $<$class 'float'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 16.5 and Type is $<$class 'float'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '21.5'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 21.5 and Type is $<$class 'float'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:13:51,949\\
Finished-Time: & 2023-02-15 07:13:53,764\\
Time-Consumption & 1.815s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak ffe/\allowbreak sleep/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:13:53,764\\
Finished-Time: & 2023-02-15 07:13:55,578\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffe/\allowbreak sleep/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:13:55,579\\
Finished-Time: & 2023-02-15 07:13:56,789\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Away mode test: zigbee/\allowbreak ffw/\allowbreak bath/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (101)\\
Start-Time: & 2023-02-15 07:13:56,790\\
Finished-Time: & 2023-02-15 07:13:57,697\\
Time-Consumption & 0.907s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Boost mode test: zigbee/\allowbreak ffw/\allowbreak bath/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (128)\\
Start-Time: & 2023-02-15 07:13:57,698\\
Finished-Time: & 2023-02-15 07:13:58,604\\
Time-Consumption & 0.907s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Activating boost mode\\
\bf{\,\textcolor{green}{Success} } & Boost timer is greater expectation (Content 900 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Setting postconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Default temperature test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak bath/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (50)\\
Start-Time: & 2023-02-15 07:13:58,605\\
Finished-Time: & 2023-02-15 07:13:59,209\\
Time-Consumption & 0.604s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Valve setpoint to 18.0)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint (is not default temperature) is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Triggering set to default temperature (23.0)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Summer mode test: zigbee/\allowbreak ffw/\allowbreak bath/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (74)\\
Start-Time: & 2023-02-15 07:13:59,210\\
Finished-Time: & 2023-02-15 07:14:00,116\\
Time-Consumption & 0.906s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ User temperature setpoint test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak bath/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (22)\\
Start-Time: & 2023-02-15 07:14:00,116\\
Finished-Time: & 2023-02-15 07:14:01,327\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Changing valve temperature setpoint to '18.0'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '23.0'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing valve temperature setpoint to '18.0'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '23.0'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak julian/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:14:01,327\\
Finished-Time: & 2023-02-15 07:14:03,140\\
Time-Consumption & 1.813s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak julian/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:14:03,141\\
Finished-Time: & 2023-02-15 07:14:04,956\\
Time-Consumption & 1.815s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffw/\allowbreak julian/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:04,956\\
Finished-Time: & 2023-02-15 07:14:06,165\\
Time-Consumption & 1.209s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:14:06,166\\
Finished-Time: & 2023-02-15 07:14:07,980\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:14:07,980\\
Finished-Time: & 2023-02-15 07:14:09,794\\
Time-Consumption & 1.813s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffw/\allowbreak livingroom/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:09,794\\
Finished-Time: & 2023-02-15 07:14:11,003\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak ffw/\allowbreak sleep/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:14:11,004\\
Finished-Time: & 2023-02-15 07:14:12,817\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak ffw/\allowbreak sleep/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:12,818\\
Finished-Time: & 2023-02-15 07:14:14,029\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 1 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:14,030\\
Finished-Time: & 2023-02-15 07:14:15,240\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 3 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:15,240\\
Finished-Time: & 2023-02-15 07:14:16,448\\
Time-Consumption & 1.207s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off synchronisation test: my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 3 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (24)\\
Start-Time: & 2023-02-15 07:14:16,448\\
Finished-Time: & 2023-02-15 07:14:17,354\\
Time-Consumption & 0.906s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'False'\\
\bf{\,Info } & Changing master device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Follower device (my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 1) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing master device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Follower device (my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 1) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak desk\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:14:17,354\\
Finished-Time: & 2023-02-15 07:14:19,168\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak desk\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:14:19,169\\
Finished-Time: & 2023-02-15 07:14:20,983\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 2 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:20,984\\
Finished-Time: & 2023-02-15 07:14:22,195\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Away mode test: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (101)\\
Start-Time: & 2023-02-15 07:14:22,196\\
Finished-Time: & 2023-02-15 07:14:23,102\\
Time-Consumption & 0.907s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 20 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Boost mode test: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (128)\\
Start-Time: & 2023-02-15 07:14:23,103\\
Finished-Time: & 2023-02-15 07:14:24,009\\
Time-Consumption & 0.906s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Activating boost mode\\
\bf{\,\textcolor{green}{Success} } & Boost timer is greater expectation (Content 899 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Setting postconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Default temperature test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (50)\\
Start-Time: & 2023-02-15 07:14:24,010\\
Finished-Time: & 2023-02-15 07:14:24,613\\
Time-Consumption & 0.603s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Valve setpoint to 20.0)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint (is not default temperature) is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Triggering set to default temperature (25.0)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Summer mode test: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (74)\\
Start-Time: & 2023-02-15 07:14:24,613\\
Finished-Time: & 2023-02-15 07:14:25,520\\
Time-Consumption & 0.907s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ User temperature setpoint test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (22)\\
Start-Time: & 2023-02-15 07:14:25,521\\
Finished-Time: & 2023-02-15 07:14:26,730\\
Time-Consumption & 1.209s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Changing valve temperature setpoint to '20.0'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 20 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 20 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '25.0'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing valve temperature setpoint to '20.0'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 20 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 20 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '25.0'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 25 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:14:26,730\\
Finished-Time: & 2023-02-15 07:14:28,545\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak dirk/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:14:28,545\\
Finished-Time: & 2023-02-15 07:14:30,359\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak gfw/\allowbreak dirk/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:30,360\\
Finished-Time: & 2023-02-15 07:14:31,571\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: my\_apps/\allowbreak gfw/\allowbreak dirk/\allowbreak powerplug/\allowbreak output/\allowbreak 4 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:31,571\\
Finished-Time: & 2023-02-15 07:14:32,782\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (50)\\
Start-Time: & 2023-02-15 07:14:32,783\\
Finished-Time: & 2023-02-15 07:14:34,596\\
Time-Consumption & 1.814s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device brightness to '65'\\
\bf{\,\textcolor{green}{Success} } & Virtual device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 65 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1 }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (81)\\
Start-Time: & 2023-02-15 07:14:34,597\\
Finished-Time: & 2023-02-15 07:14:36,410\\
Time-Consumption & 1.813s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Power on)\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing light device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Virtual device color temperature is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 8 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing virtual device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Light device brightness is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting precondition (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:36,411\\
Finished-Time: & 2023-02-15 07:14:37,621\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Brightness synchronisation test: videv/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (42)\\
Start-Time: & 2023-02-15 07:14:37,622\\
Finished-Time: & 2023-02-15 07:14:38,830\\
Time-Consumption & 1.209s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'True' (Power on)\\
\bf{\,Info } & Changing master device brightness to '35'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_2) brightness is correct (Content 35 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing master device brightness to '50'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_2) brightness is correct (Content 50 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting preconditions for master device 'False' (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Color temperature synchronisation test: videv/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (67)\\
Start-Time: & 2023-02-15 07:14:38,831\\
Finished-Time: & 2023-02-15 07:14:40,040\\
Time-Consumption & 1.209s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'True' (Power on)\\
\bf{\,Info } & Changing master device color temperature to '2'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_2) color temperature is correct (Content 2 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing master device color temperature to '5'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_2) color temperature is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Resetting preconditions for master device 'False' (Power off)\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off synchronisation test: shellies/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak synchronisation.py (24)\\
Start-Time: & 2023-02-15 07:14:40,040\\
Finished-Time: & 2023-02-15 07:14:40,947\\
Time-Consumption & 0.907s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions for master device 'False'\\
\bf{\,Info } & Changing master device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_2) state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing master device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_1) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Follower device (zigbee/\allowbreak gfw/\allowbreak floor/\allowbreak main\_light\_2) state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Away mode test: zigbee/\allowbreak gfw/\allowbreak marion/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (101)\\
Start-Time: & 2023-02-15 07:14:40,948\\
Finished-Time: & 2023-02-15 07:14:41,855\\
Time-Consumption & 0.908s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating away mode\\
\bf{\,\textcolor{green}{Success} } & Away mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Boost mode test: zigbee/\allowbreak gfw/\allowbreak marion/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (128)\\
Start-Time: & 2023-02-15 07:14:41,856\\
Finished-Time: & 2023-02-15 07:14:42,762\\
Time-Consumption & 0.906s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Activating boost mode\\
\bf{\,\textcolor{green}{Success} } & Boost timer is greater expectation (Content 900 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Setting postconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Boost timer is correct (Content 0 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Default temperature test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak marion/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (50)\\
Start-Time: & 2023-02-15 07:14:42,763\\
Finished-Time: & 2023-02-15 07:14:43,367\\
Time-Consumption & 0.604s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Valve setpoint to 18.0)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint (is not default temperature) is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Triggering set to default temperature (23.0)\\
\bf{\,\textcolor{green}{Success} } & Valve temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Summer mode test: zigbee/\allowbreak gfw/\allowbreak marion/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (74)\\
Start-Time: & 2023-02-15 07:14:43,368\\
Finished-Time: & 2023-02-15 07:14:44,275\\
Time-Consumption & 0.907s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Setting preconditions (Default setpoint)\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Activating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 5 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Deactivating summer mode\\
\bf{\,\textcolor{green}{Success} } & Summer mode is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ User temperature setpoint test for device and virtual device: zigbee/\allowbreak gfw/\allowbreak marion/\allowbreak heating\_valve }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak heating.py (22)\\
Start-Time: & 2023-02-15 07:14:44,275\\
Finished-Time: & 2023-02-15 07:14:45,486\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,Info } & Changing valve temperature setpoint to '18.0'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '23.0'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing valve temperature setpoint to '18.0'\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device user temperature is correct (Content 18 and Type is $<$class 'int'$>$).\\
\bf{\,Info } & Changing videv user temperature setpoint to '23.0'\\
\bf{\,\textcolor{green}{Success} } & Valve device temperature setpoint is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device valve temperature is correct (Content 23 and Type is $<$class 'int'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak gfw/\allowbreak marion/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:45,487\\
Finished-Time: & 2023-02-15 07:14:46,698\\
Time-Consumption & 1.211s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  
    
      
        \subsection{ Power On/\allowbreak  Off test for device and virtual device: shellies/\allowbreak stw/\allowbreak stairway/\allowbreak main\_light }
        
          
\paragraph{Testsummary}\mbox{}\\
This test was passed with the state: {\bf \textcolor{green}{Success}}.
\begin{longtabu} to \linewidth {lX}
\toprule
Caller: & /\allowbreak home/\allowbreak dirk/\allowbreak my\_repositories/\allowbreak smarthome/\allowbreak smart\_brain\_test/\allowbreak tests/\allowbreak light.py (27)\\
Start-Time: & 2023-02-15 07:14:46,698\\
Finished-Time: & 2023-02-15 07:14:47,909\\
Time-Consumption & 1.210s\\
\midrule
\multicolumn{2}{l}{\bf{Testresults:}}\\
\midrule
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing switching device state to 'True'\\
\bf{\,\textcolor{green}{Success} } & Virtual device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content True and Type is $<$class 'bool'$>$).\\
\bf{\,Info } & Changing virtual device state to 'False'\\
\bf{\,\textcolor{green}{Success} } & Switching device state is correct (Content False and Type is $<$class 'bool'$>$).\\
\bottomrule
\end{longtabu}


        
      
    
  



\end{document}