//-----------------------------------------------------------------------------
//
// Title       : phase4_tf
// Design      : mips
// Author      : Steven
// Company     : University of Washington CSE
//
//-----------------------------------------------------------------------------
//
// File        : phase4_tf.v
// Generated   : Tue Sep 19 17:57:03 2006
// From        : e:\my_designs\NewLabs\mips378\mips378\mips\src\Tests\phase4_tf_settings.txt
// By          : tb_verilog.pl ver. ver 1.2s
//
//-----------------------------------------------------------------------------
//
// Description : 
//
//-----------------------------------------------------------------------------

`timescale 1ps / 1ps
module phase4_tf;


//Internal signals declarations:
reg CLK;
reg RESET;
reg SrcASel;
reg SrcBSel;
reg Load;
reg WriteToRD;
wire Zilch_actual;
reg Zilch;
wire Overflow_actual;
reg Overflow;
reg [1:0]ALUOp;
wire [31:0]ALUOut_actual;
reg [31:0]ALUOut;
reg RegWrite;
reg [1:0]ExtOp;
reg Branch;
reg JAL;
reg JR;
reg Jump;
wire [31:0]PCOut_actual;
reg [31:0]PCOut;
reg [31:0]Inst;
reg [31:0]CPUDataIn;
wire [31:0]CPUDataOut_actual;
reg [31:0]CPUDataOut;
//LOG file declaration.
integer report_file;

//Wait time declaration used in ports monitoring.
//One parameter is declared for every port.
parameter Default_wait_time = 10;
parameter Zilch_WaitTime = Default_wait_time;//WaitTime Parameter for port Zilch
parameter Overflow_WaitTime = Default_wait_time;//WaitTime Parameter for port Overflow
parameter ALUOut_WaitTime = Default_wait_time;//WaitTime Parameter for port ALUOut
parameter PCOut_WaitTime = Default_wait_time;//WaitTime Parameter for port PCOut
parameter CPUDataOut_WaitTime = Default_wait_time;//WaitTime Parameter for port CPUDataOut

//Simulation time
parameter SimulationTime = 64'd1310000 + Default_wait_time + 1;

//Errors counter
integer errors_counter;

//Block of Comparison functions declarations. A separate function for each output port is defined.
//Comparison function for port "Zilch"
function compare_Zilch;
input  UUT_output;
input  PATTERN;
	begin
		if (UUT_output !== PATTERN) compare_Zilch = 1'b1;
		else compare_Zilch = 1'b0;
	end
endfunction
//Comparison function for port "Overflow"
function compare_Overflow;
input  UUT_output;
input  PATTERN;
	begin
		if (UUT_output !== PATTERN) compare_Overflow = 1'b1;
		else compare_Overflow = 1'b0;
	end
endfunction
//Comparison function for port "ALUOut"
function compare_ALUOut;
input [31:0] UUT_output;
input [31:0] PATTERN;
	begin
		if (UUT_output !== PATTERN) compare_ALUOut = 1'b1;
		else compare_ALUOut = 1'b0;
	end
endfunction
//Comparison function for port "PCOut"
function compare_PCOut;
input [31:0] UUT_output;
input [31:0] PATTERN;
	begin
		if (UUT_output !== PATTERN) compare_PCOut = 1'b1;
		else compare_PCOut = 1'b0;
	end
endfunction
//Comparison function for port "CPUDataOut"
function compare_CPUDataOut;
input [31:0] UUT_output;
input [31:0] PATTERN;
	begin
		if (UUT_output !== PATTERN) compare_CPUDataOut = 1'b1;
		else compare_CPUDataOut = 1'b0;
	end
endfunction

// Unit Under Test port map
	Datapath UUT (
		.CLK(CLK),
		.RESET(RESET),
		.SrcASel(SrcASel),
		.SrcBSel(SrcBSel),
		.Load(Load),
		.WriteToRD(WriteToRD),
		.Zilch(Zilch_actual),
		.Overflow(Overflow_actual),
		.ALUOp(ALUOp),
		.ALUOut(ALUOut_actual),
		.RegWrite(RegWrite),
		.ExtOp(ExtOp),
		.Branch(Branch),
		.JAL(JAL),
		.JR(JR),
		.Jump(Jump),
		.PCOut(PCOut_actual),
		.Inst(Inst),
		.CPUDataIn(CPUDataIn),
		.CPUDataOut(CPUDataOut_actual));

initial
	begin
		report_file=$fopen("$DSN\\src\\Tests\\phase4_report.log");
		errors_counter = 0;
		#SimulationTime;
		if (errors_counter)
		begin
			$display("Errors were encountered, differences are listed in phase4_report.log");
			$fdisplay(report_file,"Some vectors failed.");
		end
		else
		begin
			$display("All vectors passed.");
			$fdisplay(report_file,"All vectors passed.");
		end
		$fclose(report_file);
		$finish;
	end

//Below code was generated based on waveform file: "e:\my_designs\NewLabs\mips378\mips378\mips\compile\phase4.vhr"

initial
begin : STIMUL // begin of stimulus process
	#0
	CLK = 1'b0;
	ALUOut = 32'b00000000000000000000000000000001;
	WriteToRD = 1'b0;
	Load = 1'b0;
	Overflow = 1'b0;
	Zilch = 1'b0;
	SrcASel = 1'b0;
	SrcBSel = 1'b1;
	ALUOp = 2'b11;
	RESET = 1'b1;
	Jump = 1'b0;
	PCOut = 32'b00000000000000000000000000000000;
	Branch = 1'b0;
	ExtOp = 2'b01;
	JR = 1'b0;
	JAL = 1'b0;
	RegWrite = 1'b1;
	Inst = 32'b00100000000000100000000000000001;
	CPUDataIn = 32'b000000000000000000000000XXXXXXXX;
	CPUDataOut = 32'b00000000000000000000000000000010;
    #340000; //0
	RESET = 1'b0;
    #10000; //340000
	CLK = 1'b1;
	ALUOut = 32'b11111111111111111111111111111111;
	PCOut = 32'b00000000000000000000000000000100;
	Inst = 32'b00100000000000111111111111111111;
	CPUDataOut = 32'b00000000000000000000000000000011;
    #20000; //350000
	CLK = 1'b0;
    #20000; //370000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000000;
	Overflow = 1'b0;
	Zilch = 1'b1;
	SrcBSel = 1'b0;
	ALUOp = 2'b00;
	Jump = 1'b1;
	PCOut = 32'b00000000000000000000000000001000;
	ExtOp = 2'b00;
	RegWrite = 1'b0;
	Inst = 32'b00001000000000000000000001000111;
	CPUDataOut = 32'b00000000000000000000000000000000;
    #20000; //390000
	CLK = 1'b0;
    #20000; //410000
	CLK = 1'b1;
	PCOut = 32'b00000000000000000000000100011100;
	Inst = 32'b00001000000000000000000000000101;
    #20000; //430000
	CLK = 1'b0;
    #20000; //450000
	CLK = 1'b1;
	ALUOp = 2'b01;
	Jump = 1'b0;
	PCOut = 32'b00000000000000000000000000010100;
	Branch = 1'b1;
	Inst = 32'b00010000000000000000000000001001;
    #20000; //470000
	CLK = 1'b0;
    #20000; //490000
	CLK = 1'b1;
	PCOut = 32'b00000000000000000000000000111100;
	Inst = 32'b00010000000000001111111111111010;
    #20000; //510000
	CLK = 1'b0;
    #20000; //530000
	CLK = 1'b1;
	ALUOut = 32'b11111111111111111111111111111111;
	Zilch = 1'b0;
	PCOut = 32'b00000000000000000000000000101000;
	Inst = 32'b00010000000000100000000000000011;
	CPUDataOut = 32'b00000000000000000000000000000001;
    #20000; //550000
	CLK = 1'b0;
    #20000; //570000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000000;
	WriteToRD = 1'b1;
	Overflow = 1'b0;
	Zilch = 1'b1;
	SrcASel = 1'b1;
	ALUOp = 2'b10;
	PCOut = 32'b00000000000000000000000000101100;
	Branch = 1'b0;
	ExtOp = 2'b11;
	RegWrite = 1'b1;
	Inst = 32'b00000000000000000000000000000000;
	CPUDataOut = 32'b00000000000000000000000000000000;
    #20000; //590000
	CLK = 1'b0;
    #20000; //610000
	CLK = 1'b1;
	WriteToRD = 1'b0;
	SrcASel = 1'b0;
	ALUOp = 2'b00;
	Jump = 1'b1;
	PCOut = 32'b00000000000000000000000000110000;
	ExtOp = 2'b00;
	RegWrite = 1'b0;
	Inst = 32'b00001000000000000000000000010100;
    #20000; //630000
	CLK = 1'b0;
    #20000; //650000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000001;
	Zilch = 1'b0;
	ALUOp = 2'b01;
	Jump = 1'b0;
	PCOut = 32'b00000000000000000000000001010000;
	Branch = 1'b1;
	Inst = 32'b00010100010000000000000000001011;
    #20000; //670000
	CLK = 1'b0;
    #20000; //690000
	CLK = 1'b1;
	ALUOut = 32'b11111111111111111111111111111111;
	PCOut = 32'b00000000000000000000000010000000;
	Inst = 32'b00010100000000101111111111111000;
	CPUDataOut = 32'b00000000000000000000000000000001;
    #20000; //710000
	CLK = 1'b0;
    #20000; //730000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000000;
	Zilch = 1'b1;
	PCOut = 32'b00000000000000000000000001100100;
	Inst = 32'b00010100000000000000000000000011;
	CPUDataOut = 32'b00000000000000000000000000000000;
    #20000; //750000
	CLK = 1'b0;
    #20000; //770000
	CLK = 1'b1;
	WriteToRD = 1'b1;
	SrcASel = 1'b1;
	ALUOp = 2'b10;
	PCOut = 32'b00000000000000000000000001101000;
	Branch = 1'b0;
	ExtOp = 2'b11;
	RegWrite = 1'b1;
	Inst = 32'b00000000000000000000000000000000;
    #20000; //790000
	CLK = 1'b0;
    #20000; //810000
	CLK = 1'b1;
	WriteToRD = 1'b0;
	SrcASel = 1'b0;
	ALUOp = 2'b00;
	Jump = 1'b1;
	PCOut = 32'b00000000000000000000000001101100;
	ExtOp = 2'b00;
	RegWrite = 1'b0;
	Inst = 32'b00001000000000000000000000100101;
    #20000; //830000
	CLK = 1'b0;
    #20000; //850000
	CLK = 1'b1;
	ALUOut = 32'b11111111111111111111111111111111;
	Overflow = 1'b0;
	Zilch = 1'b0;
	Jump = 1'b0;
	PCOut = 32'b00000000000000000000000010010100;
	Branch = 1'b1;
	Inst = 32'b00011000011000000000000000001011;
    #20000; //870000
	CLK = 1'b0;
    #20000; //890000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000000;
	Overflow = 1'b0;
	Zilch = 1'b1;
	PCOut = 32'b00000000000000000000000011000100;
	Inst = 32'b00011000000000001111111111111000;
    #20000; //910000
	CLK = 1'b0;
    #20000; //930000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000001;
	Zilch = 1'b0;
	PCOut = 32'b00000000000000000000000010101000;
	Inst = 32'b00011000010000000000000000000011;
    #20000; //950000
	CLK = 1'b0;
    #20000; //970000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000000;
	WriteToRD = 1'b1;
	Zilch = 1'b1;
	SrcASel = 1'b1;
	ALUOp = 2'b10;
	PCOut = 32'b00000000000000000000000010101100;
	Branch = 1'b0;
	ExtOp = 2'b11;
	RegWrite = 1'b1;
	Inst = 32'b00000000000000000000000000000000;
    #20000; //990000
	CLK = 1'b0;
    #20000; //1010000
	CLK = 1'b1;
	WriteToRD = 1'b0;
	SrcASel = 1'b0;
	ALUOp = 2'b00;
	Jump = 1'b1;
	PCOut = 32'b00000000000000000000000010110000;
	ExtOp = 2'b00;
	RegWrite = 1'b0;
	Inst = 32'b00001000000000000000000000110110;
    #20000; //1030000
	CLK = 1'b0;
    #20000; //1050000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000001;
	Zilch = 1'b0;
	Jump = 1'b0;
	PCOut = 32'b00000000000000000000000011011000;
	Branch = 1'b1;
	Inst = 32'b00011100010000000000000000001011;
    #20000; //1070000
	CLK = 1'b0;
    #20000; //1090000
	CLK = 1'b1;
	PCOut = 32'b00000000000000000000000100001000;
	Inst = 32'b00011100010000001111111111111000;
    #20000; //1110000
	CLK = 1'b0;
    #20000; //1130000
	CLK = 1'b1;
	ALUOut = 32'b11111111111111111111111111111111;
	Overflow = 1'b0;
	PCOut = 32'b00000000000000000000000011101100;
	Inst = 32'b00011100011000000000000000000011;
    #20000; //1150000
	CLK = 1'b0;
    #20000; //1170000
	CLK = 1'b1;
	ALUOut = 32'b00000000000000000000000000000000;
	WriteToRD = 1'b1;
	Overflow = 1'b0;
	Zilch = 1'b1;
	SrcASel = 1'b1;
	ALUOp = 2'b10;
	PCOut = 32'b00000000000000000000000011110000;
	Branch = 1'b0;
	ExtOp = 2'b11;
	RegWrite = 1'b1;
	Inst = 32'b00000000000000000000000000000000;
    #20000; //1190000
	CLK = 1'b0;
    #20000; //1210000
	CLK = 1'b1;
	WriteToRD = 1'b0;
	SrcASel = 1'b0;
	ALUOp = 2'b00;
	Jump = 1'b1;
	PCOut = 32'b00000000000000000000000011110100;
	ExtOp = 2'b00;
	RegWrite = 1'b0;
	Inst = 32'b00001000000000000000000001001010;
    #20000; //1230000
	CLK = 1'b0;
    #20000; //1250000
	CLK = 1'b1;
	WriteToRD = 1'b1;
	SrcASel = 1'b1;
	ALUOp = 2'b10;
	Jump = 1'b0;
	PCOut = 32'b00000000000000000000000100101000;
	ExtOp = 2'b11;
	RegWrite = 1'b1;
	Inst = 32'b00000000000000000000000000000000;
    #20000; //1270000
	CLK = 1'b0;
    #20000; //1290000
	CLK = 1'b1;
	WriteToRD = 1'bx;
	Load = 1'bx;
	Overflow = 1'bx;
	SrcASel = 1'bx;
	SrcBSel = 1'bx;
	ALUOp = 2'bXX;
	Jump = 1'bx;
	PCOut = 32'b00000000000000000000000100101100;
	Branch = 1'bx;
	ExtOp = 2'bXX;
	JR = 1'bx;
	JAL = 1'bx;
	RegWrite = 1'bx;
	Inst = 32'bXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;
	CPUDataIn = 32'bXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;
	CPUDataOut = 32'bXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;
end // end of stimulus process
	



//Set of always bloks for ports monitoring.
//One block per output port.
//Always block for monitoring port "Zilch";
always @(Zilch or Zilch_actual)
	begin
		#Zilch_WaitTime
		if (compare_Zilch(Zilch,Zilch_actual))
		begin
			errors_counter = errors_counter + 1;
			$fdisplay(report_file,$realtime,,"ps; Port Zilch: Expected value is %b, Actual value is %b",Zilch,Zilch_actual);
			$display($realtime,,"ps; Error on port Zilch: Expected value is %b, Actual value is %b",Zilch,Zilch_actual);
		end
	end
//Always block for monitoring port "Overflow";
always @(Overflow or Overflow_actual)
	begin
		#Overflow_WaitTime
		if (compare_Overflow(Overflow,Overflow_actual))
		begin
			errors_counter = errors_counter + 1;
			$fdisplay(report_file,$realtime,,"ps; Port Overflow: Expected value is %b, Actual value is %b",Overflow,Overflow_actual);
			$display($realtime,,"ps; Error on port Overflow: Expected value is %b, Actual value is %b",Overflow,Overflow_actual);
		end
	end
//Always block for monitoring port "ALUOut";
always @(ALUOut or ALUOut_actual)
	begin
		#ALUOut_WaitTime
		if (compare_ALUOut(ALUOut,ALUOut_actual))
		begin
			errors_counter = errors_counter + 1;
			$fdisplay(report_file,$realtime,,"ps; Port ALUOut: Expected value is %b, Actual value is %b",ALUOut,ALUOut_actual);
			$display($realtime,,"ps; Error on port ALUOut: Expected value is %b, Actual value is %b",ALUOut,ALUOut_actual);
		end
	end
//Always block for monitoring port "PCOut";
always @(PCOut or PCOut_actual)
	begin
		#PCOut_WaitTime
		if (compare_PCOut(PCOut,PCOut_actual))
		begin
			errors_counter = errors_counter + 1;
			$fdisplay(report_file,$realtime,,"ps; Port PCOut: Expected value is %b, Actual value is %b",PCOut,PCOut_actual);
			$display($realtime,,"ps; Error on port PCOut: Expected value is %b, Actual value is %b",PCOut,PCOut_actual);
		end
	end
//Always block for monitoring port "CPUDataOut";
always @(CPUDataOut or CPUDataOut_actual)
	begin
		#CPUDataOut_WaitTime
		if (compare_CPUDataOut(CPUDataOut,CPUDataOut_actual))
		begin
			errors_counter = errors_counter + 1;
			$fdisplay(report_file,$realtime,,"ps; Port CPUDataOut: Expected value is %b, Actual value is %b",CPUDataOut,CPUDataOut_actual);
			$display($realtime,,"ps; Error on port CPUDataOut: Expected value is %b, Actual value is %b",CPUDataOut,CPUDataOut_actual);
		end
	end

endmodule