//  /*--------------------------------------------------------*\
//  |   Main Program: Simple tester for Natural Root
//  |*--------------------------------------------------------*|
//  |   Date:      Summer Quarter 2006
//  |   Author:    Bruce W. Weide (adapted from "anonymous")  
//  |   
//  |   Brief User's Manual:
//  |   Allows user either to exercise the Root operation
//  |   in an interactive menu-driven mode or in a batch
//  |   file mode (using input redirection).
//  |   
//  |   Modified:  8 April 2004
//  |   Modifier:  Wayne D. Heym
//  |   Modification:
//  |   Support for comments in test scripts
//  |   
//  |   Modified:  20 May 2005
//  |   Modifier:  Wayne D. Heym
//  |   Modification:
//  |   Weakened precondition of Root from "r > 1" to "r > 0"
//  |
//  |   Modified:  6 December 2006
//  |   Modifier:  Tim Long
//  |   Modification:
//  |   Request expected outgoing values for each test case
//  |
//  \*--------------------------------------------------------*/

///-------------------------------------------------------------
/// Global Context ---------------------------------------------
///-------------------------------------------------------------

#include "RESOLVE_Foundation.h"
#include "CI/Natural/Power_2.h"

///-------------------------------------------------------------
/// Interface --------------------------------------------------
///-------------------------------------------------------------

global_procedure Root (
	alters Natural_Power_2& n,
	preserves Integer r
    );
    /*!
	requires
	    r > 0
	ensures
	    n^(r) <= #n < (n+1)^(r)
    !*/

//--------------------------------------------------------------

procedure_body Root (
	alters Natural_Power_2& n,
	preserves Integer r
    )
{

    // for students to fill in

}

//--------------------------------------------------------------
//--------------------------------------------------------------

program_body main ()
{
    object Character_IStream input;
    object Character_OStream output;
    object Text response;
    object Boolean interactive_mode;
    object Integer r, r_exp_out;
    object Natural_Power_2 n, n_exp_out;

    // Open input and output streams
    
    input.Open_External ("");
    output.Open_External ("");

    // Ask user about interactive mode
    
    output << "Run in interactive mode (y/n)? ";
    input >> response;
    interactive_mode = (response == "y");
    output << "\n";

    // Ask user for whether to test

    if (interactive_mode)
    {
	output << "Start testing (y/n)? ";
    }
    input >> response;

    // Execute interactive testing loop until finished

    while (response != "n")
    {
	if (response != "y")
	{
	    output << response << '\n';
	}
	else
	{
	    // Get values for n and r for this test case
	    
	    if (interactive_mode)
	    {
		output << "n = ";
	    }
	    input >> n;
	    
	    if (interactive_mode)
	    {
		output << "r = ";
	    }
	    input >> r;

	    // Get expected output for n and r for this test case
	
	    if (interactive_mode)
	    {
		output << "\nexpected output for n = ";
	    }
	    input >> n_exp_out;

	    if (interactive_mode)
	    {
		output << "expected output for r = ";
	    }
	    input >> r_exp_out;	    
	    
	    // Report results of this test case
	    
	    output << "-------------------------------------------------\n"
		   << "                       |  n = " << n << '\n'
		   << "                       |  r = " << r << '\n'
		   << "-------------------------------------------------\n"
		   << "Root (n, r);           |\n"
		   << "-------------------------------------------------\n";
	    
	    Root (n, r);
	    
	    output << "                       |  n = " << n << '\n'
		   << "                       |  r = " << r << '\n'
		   << "-------------------------------------------------\n";
	    
	    if (r != r_exp_out)
	    {
		output << "\nERROR DETECTED:\n"
		     << "    expected r = " 
		     << r_exp_out << '\n'
		     << "    observed r = "
		     << r << "\nEXECUTION TERMINATING\n";
		return 0;
	    }

	    if (n.Compare (n_exp_out) != 0)
	    {
		output << "ERROR DETECTED:\n"
		     << "    expected n = " 
		     << n_exp_out << '\n'
		     << "    observed n = "
		     << n <<  "\nEXECUTION TERMINATING\n";
		return 0;
	    }

	}
	
	// Determine whether to continue testing
	
	if (interactive_mode)
	{
	    output << "\nContinue testing (y/n)? ";
	}
	input >> response;
    }

    // Close input and output streams
    
    input.Close_External ();
    output.Close_External ();
}