#ifndef CONTACT_H
#define CONTACT_H

#include <iostream>
#include <string>

#include "name.h"
#include "address.h"

class Contact {
  Name theName;
  Address theAddress;

public:
  Contact (Name nm, Address addr)
    : theName(nm), theAddress(addr)
  {}


  Name getName() const   {return theName;}
  void setName (Name nm) {theName= nm;}

  Address getAddress() const     {return theAddress;}
  void setAddress (Address addr) {theAddress = addr;}

  bool operator== (const Contact& right) const
  {
    return theName == right.theName
      && theAddress == right.theAddress;
  }

  bool operator< (const Contact& right) const
  {
    return (theName < right.theName)
      || (theName == right.theName
	  && theAddress < right.theAddress);
  }
};

inline
std::ostream& operator<< (std::ostream& out, const Contact& c)
{
  out << c.getName() << " @ " << c.getAddress();
  return out;
}


#endif

#ifndef NAME_H
#define NAME_H

#include <iostream>
#include <string>

struct Name {
  std::string last;
  std::string first;
  std::string middle;


  Name (std::string lastName,
	   std::string firstName,
	   std::string middleName)
    : last(lastName), first(firstName),
      middle(middleName)
    {}

  bool operator== (const Name& right) const;
  bool operator< (const Name& right) const;

};

std::ostream& operator<< (std::ostream& out, const Name& addr);


#endif


#ifndef ADDRESS_H
#define ADDRESS_H

#include <iostream>
#include <string>

struct Address {
  std::string street1;
  std::string street2;
  std::string city;
  std::string state;
  std::string zipcode;

  Address (std::string str1,
	   std::string str2,
	   std::string cty,
	   std::string stte,
	   std::string zip)
    : street1(str1), street2(str2),
      city(cty), state(stte), zipcode(zip)
    {}

  bool operator== (const Address& right) const;
  bool operator< (const Address& right) const;

};

std::ostream& operator<< (std::ostream& out, const Address& addr);


#endif

#ifndef CONTACT_H
#define CONTACT_H

#include <iostream>
#include <string>

typedef std::string Name;
typedef std::string Address;

class Contact {
  Name theName;
  Address theAddress;

public:
  Contact() {}

  Contact (Name nm, Address addr)
    : theName(nm), theAddress(addr)
  {}


  Name getName() const   {return theName;}
  void setName (Name nm) {theName= nm;}

  Address getAddress() const     {return theAddress;}
  void setAddress (Address addr) {theAddress = addr;}

  bool operator== (const Contact& right) const
  {
    return theName == right.theName
      && theAddress == right.theAddress;
  }

  bool operator< (const Contact& right) const
  {
    return (theName < right.theName)
      || (theName == right.theName
          && theAddress < right.theAddress);
  }
};

inline
std::ostream& operator<< (std::ostream& out, const Contact& c)
{
  out << c.getName() << " @ " << c.getAddress();
  return out;
}


#endif

package Pictures;

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.image.ImageObserver;
import java.text.AttributedCharacterIterator;

/**
 * Special version of Graphics for testing that simply writes all graphics requests to
 * a string.
 * 
 * @author zeil
 *
 */
public class GraphicsStub extends Graphics {

    private StringBuffer log;

    public GraphicsStub() {
        log = new StringBuffer();
    }

    public void clearRect(int arg0, int arg1, int arg2, int arg3) {
        entering("clearRect",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void clipRect(int arg0, int arg1, int arg2, int arg3) {
        entering("clipRect",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void copyArea(int arg0, int arg1, int arg2, int arg3, int arg4,
            int arg5) {
        entering("copyArea",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5);
    }

    public Graphics create() {
        entering("create", "");
        return new GraphicsStub();
    }

    public void dispose() {
        entering("dispose", "");
    }

    public void drawArc(int arg0, int arg1, int arg2, int arg3, int arg4,
            int arg5) {
        entering("drawArc",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5);
    }

    public boolean drawImage(Image arg0, int arg1, int arg2, ImageObserver arg3) {
        entering("drawImage",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
        return true;
    }

    public boolean drawImage(Image arg0, int arg1, int arg2, Color arg3,
            ImageObserver arg4) {
        entering("drawImage",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
        return true;
    }

    public boolean drawImage(Image arg0, int arg1, int arg2, int arg3,
            int arg4, ImageObserver arg5) {
        entering("drawImage",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4);
        return true;
    }

    public boolean drawImage(Image arg0, int arg1, int arg2, int arg3,
            int arg4, Color arg5, ImageObserver arg6) {
        entering("drawImage",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5);
        return true;
    }

    public boolean drawImage(Image arg0, int arg1, int arg2, int arg3,
            int arg4, int arg5, int arg6, int arg7, int arg8, ImageObserver arg9) {
        entering("drawImage",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5
                + arg6 + ":" + arg7 + ":" + arg8);
        return true;
    }

    public boolean drawImage(Image arg0, int arg1, int arg2, int arg3,
            int arg4, int arg5, int arg6, int arg7, int arg8, Color arg9,
            ImageObserver arg10) {
        entering("drawImage",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5
                + arg6 + ":" + arg7 + ":" + arg8 + ":" + arg9);
        return true;
    }

    public void drawLine(int arg0, int arg1, int arg2, int arg3) {
        entering("drawLine",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void drawOval(int arg0, int arg1, int arg2, int arg3) {
        entering("drawOval",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void drawPolygon(int[] arg0, int[] arg1, int arg2) {
        entering("drawPolygon",
                "" + arg0 + ":" + arg1 + ":" + arg2);
    }

    public void drawPolyline(int[] arg0, int[] arg1, int arg2) {
        entering("drawPolyline",
                "" + arg0 + ":" + arg1 + ":" + arg2);
    }

    public void drawRoundRect(int arg0, int arg1, int arg2, int arg3, int arg4,
            int arg5) {
        entering("drawRoundRect",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5);
    }

    public void drawString(String arg0, int arg1, int arg2) {
        entering("drawString",
                "" + arg0 + ":" + arg1 + ":" + arg2);
    }

    public void drawString(AttributedCharacterIterator arg0, int arg1, int arg2) {
        entering("drawString",
                "" + arg0 + ":" + arg1 + ":" + arg2);
    }

    public void fillArc(int arg0, int arg1, int arg2, int arg3, int arg4,
            int arg5) {
        entering("fillArc",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5);
    }

    public void fillOval(int arg0, int arg1, int arg2, int arg3) {
        entering("fillOval",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void fillPolygon(int[] arg0, int[] arg1, int arg2) {
        entering("fillPolygon",
                "" + arg0 + ":" + arg1 + ":" + arg2);
    }

    public void fillRect(int arg0, int arg1, int arg2, int arg3) {
        entering("fillRect",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void fillRoundRect(int arg0, int arg1, int arg2, int arg3, int arg4,
            int arg5) {
        entering("fillRoundRect",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3 + ":" + arg4 + ":" + arg5);
    }

    private Shape clip = null;
    public Shape getClip() {
        return clip;
    }

    public Rectangle getClipBounds() {
        return null;
    }

    private Color color;
    public Color getColor() {
        return color;
    }

    public Font getFont() {
        return null;
    }

    public FontMetrics getFontMetrics(Font arg0) {
        return null;
    }

    public void setClip(Shape arg0) {
        entering("setClip",
                "" + arg0);
        clip = arg0;
    }

    public void setClip(int arg0, int arg1, int arg2, int arg3) {
        entering("setClip",
                "" + arg0 + ":" + arg1 + ":" + arg2 + ":" + arg3);
    }

    public void setColor(Color arg0) {
        entering("setColor",
                "" + arg0);
        color = arg0;
    }

    public void setFont(Font arg0) {
        entering("setFont",
                "" + arg0);
    }

    public void setPaintMode() {
        entering("setPaintMode", "");
    }

    public void setXORMode(Color arg0) {
        entering("setXORMode",
                "" + arg0);
    }

    public void translate(int arg0, int arg1) {
        entering("translate",
                "" + arg0 + ":" + arg1);
    }

    public String toString()
    {
        return log.toString();
    }

    public void clear()
    {
        log = new StringBuffer();
    }

    private void entering(String functionName, String args)
    {
        log.append(functionName);
        log.append(": ");
        log.append(args);
        log.append("\n");
    }

}

package PictureTests;
import java.awt.Color;
import java.awt.Point;
import java.lang.reflect.Method;
import java.util.Scanner;

import junit.framework.*;
import junit.textui.TestRunner;
import Pictures.GraphicsStub;
import Pictures.LineSegment;
import Pictures.Shape;


/**
 * Test of the LineSegment class
 */
public class LineSegmentTest extends TestCase {
    ⋮
    public void testPlot()
    {
        Point p1 = new Point(22, 341);
        Point p2 = new Point(104, 106);
        LineSegment ls = new LineSegment(p1, p2, Color.blue, Color.red);
        
        GraphicsStub g = new GraphicsStub();
        GraphicsStub gblue = new GraphicsStub();
        gblue.setColor(Color.blue);
        GraphicsStub gline1 = new GraphicsStub();
        gline1.drawLine(22, 341, 104, 106);
        GraphicsStub gline2 = new GraphicsStub();
        gline2.drawLine(104, 106, 22, 341);

        ls.plot(g);
        assertTrue (g.toString().contains(gblue.toString()));
        assertTrue (g.toString().contains(gline1.toString()) 
                    || g.toString().contains(gline2.toString()));
    }
    ⋮

package edu.odu.cs.espreadsheet.cli;

import static org.junit.Assert.assertTrue;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;

import org.junit.BeforeClass;
import org.junit.Test;

public final class ITestCLI {

	static Path testDataDir = Paths.get("target/itest-data");
	
	@BeforeClass
	public static void setupDir()
	{
		File dir = testDataDir.toFile();
		dir.mkdir();
	}
	
	@Test
	public void testRunNonExistentFile() throws FileNotFoundException, IOException {
		Run running = new Run("target/testdata/nonExistent.ss");

		boolean thrown = false;
		try {
			running.doIt();
		} catch (FileNotFoundException ex) {
			thrown = true;
		}
		assertTrue (thrown);
	}

	
	@Test
	public void testBadFile() throws FileNotFoundException, IOException {
		
		Path badDataPath = testDataDir.resolve("badData.ss");
		Files.write(badDataPath, 
				Arrays.asList("a12", "ab2=1"), 
				Charset.forName("US-ASCII"));

		Run running = new Run(badDataPath.toString());
		boolean thrown = false;
		try {
			running.doIt();
		} catch (IOException ex) {
			thrown = true;
		}
		assertTrue (thrown);
	}

	@Test
	public void testSimpleAssignments() throws FileNotFoundException, IOException {
		
		Path simpleDataPath = testDataDir.resolve("simpleData.ss");
		Files.write(simpleDataPath, 
				Arrays.asList("a12=12", "ab2=1"), 
				Charset.forName("US-ASCII"));
		
		// Capture System.out
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
	    PrintStream stringStream = new PrintStream(baos);
	    PrintStream savedOut = System.out;
	    System.setOut (stringStream);
	    
		try {
			Run running = new Run(simpleDataPath.toString());
			running.doIt();
		} finally {
			//Restore System.out
			System.out.flush();
			System.setOut(savedOut);
		}
		String reportOutput = baos.toString();
		assertTrue (reportOutput.startsWith("a12=12"));
		assertTrue (reportOutput.contains("ab2=1"));	
	}

	@Test
	public void testEvaluationPerformed() throws FileNotFoundException, IOException {
		
		Path simpleDataPath = testDataDir.resolve("evalData.ss");
		
		Files.write(simpleDataPath, 
				Arrays.asList("a12=10*ab2", "ab2=2"), 
				Charset.forName("US-ASCII"));
		
		// Capture System.out
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
	    PrintStream stringStream = new PrintStream(baos);
	    PrintStream savedOut = System.out;
	    System.setOut (stringStream);
	    
		try {
			Run running = new Run(simpleDataPath.toString());
			running.doIt();
		} finally {
			//Restore System.out
			System.out.flush();
			System.setOut(savedOut);
		}
		String reportOutput = baos.toString();
		assertTrue (reportOutput.startsWith("a12=20"));
		assertTrue (reportOutput.contains("ab2=2"));	
	}
	
	
}

package edu.odu.cs.espreadsheet.cli;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

import mockit.Expectations;
import mockit.Mocked;

import org.junit.Test;

import edu.odu.cs.espreadsheet.Spreadsheet;

public final class TestCLI {

	
    @Mocked Spreadsheet ss; ➀
	
	@Test
	public void testRun() throws FileNotFoundException, IOException {
		// Record phase: expectations on mocks are recorded; empty if there is nothing to record.
		new Expectations() {{  ➁
		    ss.load(withAny((Reader)null));   ➂
		    ss.report(withAny((Writer)null)); ➃
		}};


		// Replay phase: invocations on mocks are "replayed"; here the code under test is exercised.
		Run running = new Run("ivy.xml"); ➄
		running.doIt();
		
		// Verify phase: expectations on mocks are verified; empty if there is nothing to verify.
		➅
	}

}

package edu.odu.cs.espreadsheet;

import edu.odu.cs.espreadsheet.expressions.Expression;
import edu.odu.cs.espreadsheet.values.Value;


/**
 * A single cell withing a spreadsheet.
 * 
 * @author zeil
 *
 */
public
class Cell
{

        private Spreadsheet ssheet;
        private CellName name;
        private Expression formula;
        private Value value;


        /**
         * Create a new cell
         * @param sheet the spreadsheet containing this cell
         * @param name  the name of this cell
         */
        public Cell (Spreadsheet ssheet, CellName name)
        {
                this.ssheet = ssheet;
                this.name = name;
                this.formula = null;
                this.value = null;
        }


        public CellName getName() 
        {
                return name;
        }

        /**
         * Get the formula associated with this cell.
         * 
         * @return an expression or null if the cell is empty
         */
        public Expression getFormula() 
        {
                return formula;
        }

        public void putFormula(Expression e)
        {
                formula = e;
                value = null;
        }

        public Value getValue() 
        {
                if (value == null && formula != null)
                        value = formula.evaluate(ssheet);
                return value;
        }


        public String toString()
        {
                return name.toString() + "::" + formula + "::" + value;
        }


        public int hashCode()
        {
                return name.hashCode();
        }

        public boolean equals(Object obj)
        {
                if (obj instanceof Cell) {
                        Cell other = (Cell)obj;
                        return name.equals(other.name);
                } else
                        return false;
        }




}

package edu.odu.cs.espreadsheet.expressions;

import java.io.StringReader;

import edu.odu.cs.espreadsheet.ExpressionParseError;
import edu.odu.cs.espreadsheet.Spreadsheet;
import edu.odu.cs.espreadsheet.values.Value;


/**
 * Expressions can be thought of as trees.  Each non-leaf node of the tree
 * contains an operator, and the children of that node are the subexpressions
 * (operands) that the operator operates upon.  Constants, cell references,
 * and the like form the leaves of the tree.
 * 
 * For example, the expression (a2 + 2) * c26 is equivalent to the tree:
 * 
 *              *
 *             / \
 *            +   c26
 *           / \
 *         a2   2
 * 
 * @author zeil
 *
 */
public abstract class Expression implements Cloneable
{

        /**
         *  How many operands does this expression node have?
         *  
         * @return # of operands required by this operator
         */
        public abstract int arity();

        /**
         *  Get the k_th operand
         * @param k operand number
         * @return k_th operand if 0 < k < arity()
         * @throws IndexOutOfBoundsException if k is outside of those bounds
         */
        public abstract Expression operand(int k) throws IndexOutOfBoundsException;


        /**
         *  Evaluate this expression, using the provided spreadsheet to resolve 
         *  any cell referneces.
         *  
         * @param usingSheet spreadsheet form which to obtain values of 
         * cells referenced by this expression
         * 
         * @return value of the expression or null if the cell is empty
         */
        public abstract Value evaluate(Spreadsheet usingSheet);





        /**
         * Copy this expression (deep copy), altering any cell references
         * by the indicated offsets except where the row or column is "fixed"
         * by a preceding $. E.g., if e is  2*D4+C$2/$A$1, then
         * e.copy(1,2) is 2*E6+D$2/$A$1, e.copy(-1,4) is 2*C8+B$2/$A$1
         * 
         * @param colOffset number of columns to offset this copy
         * @param rowOffset number of rows to offset this copy
         * @return a copy of this expression, suitable for placing into 
         *           a cell (ColOffSet,rowOffset) away from its current position.
         *             
         */
        public abstract Expression clone (int colOffset, int rowOffset);

        /**
         * Copy this expression.
         */
        @Override
        public Expression clone ()
        {
                return clone(0,0);
        }


        /**
         * Attempt to convert the given string into an expression.
         * @param in
         * @return
         */
        public static Expression parse (String in) throws ExpressionParseError
        {
                try {
                        parser p = new parser(new ExpressionScanner(new StringReader(in)));
                    Expression expr = (Expression)p.parse().value;
                    return expr;
                } catch (Exception ex) {
                        throw new ExpressionParseError("Cannnot parse " + in);
                }
        }


        @Override
        public String toString ()
        {
	    ⋮
        }


        @Override
        public abstract boolean equals (Object obj);
        
        @Override
        public abstract int hashCode ();
        
        

        // The following control how the expression gets printed by 
        // the default implementation of toString

        /**
         * If true, print in inline form.
         * If false, print as functionName(comma-separated-list).
         * 
         * @return indication of whether to print in inline form.
         * 
         */
        public abstract boolean isInline();

        /**
         * Parentheses are placed around an expression whenever its precedence
         * is lower than the precedence of an operator (expression) applied to it.
         * E.g., * has higher precedence than +, so we print 3*(a1+1) but not
         * (3*a1)+1
         * 
         * @return precedence of this operator
         */
        public abstract int precedence();


        /**
         * Returns the name of the operator for printing purposes.
         * For constants/literals, this is the string version of the constant value.
         * 
         * @return the name of the operator for printing purposes.
         */
        public abstract String getOperator();



}

/**
 * 
 */
package edu.odu.cs.espreadsheet;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import mockit.Expectations;
import mockit.Mocked;

import org.junit.Test;

import edu.odu.cs.espreadsheet.expressions.Expression;
import edu.odu.cs.espreadsheet.expressions.NumericLiteral;

/**
 * @author zeil
 *
 */
public class MockTestSpreadSheet {
        
        @Mocked Expression expr;

        @Test
        public final void testConstructor() {
                Spreadsheet s = new Spreadsheet();
                assertEquals (0, s.getDimension());
                assertNull (s.getFormula(new CellName("a1")));
                assertFalse (s.iterator().hasNext());
        }
        
        
        @Test
        public final void testNumericLiteralInsertion() throws ExpressionParseError {
                
                final Spreadsheet s = new Spreadsheet();
                final String input = "1.234";

                new Expectations() {{
                        Expression.parse(input); result = new NumericLiteral(input);
                        expr.toString(); result = "1.234";
                }};
                
                CellName cn = new CellName("a1");
                assertNull (s.getFormula(cn));
                assertNull (s.getValue(cn));
                s.assignFormula(cn, input);
                assertEquals (input, s.getFormula(cn));
        }
        
        @Test(expected = ExpressionParseError.class)
        public final void testParsingError() throws ExpressionParseError {
                
                final Spreadsheet s = new Spreadsheet();
                final String input = "1.23.4";
                new Expectations() {{
                        Expression.parse(input); result = new ExpressionParseError();
                }};

                CellName cn = new CellName("b2");
                assertNull (s.getFormula(cn));
                assertNull (s.getValue(cn));
                s.assignFormula(cn, input);
                assertTrue(false);
        }

        
        
}

package edu.odu.cs.espreadsheet;


import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.io.StringReader;

import org.junit.Test;

import edu.odu.cs.espreadsheet.values.NumericValue;
import edu.odu.cs.espreadsheet.values.Value;

/**
 * @author zeil
 *
 */
public class ITestSpreadSheet {
        
        

        @Test
        public final void testConstructor() {
                Spreadsheet s = new Spreadsheet();
                assertEquals (0, s.getDimension());
                assertNull (s.getFormula(new CellName("a1")));
                assertFalse (s.iterator().hasNext());
        }
        
        
    @Test
        public final void testNumericLiteralInsertion() throws ExpressionParseError {
                
                final Spreadsheet s = new Spreadsheet();

                CellName cn = new CellName("a1");
                assertNull (s.getFormula(cn));
                assertNull (s.getValue(cn));
                s.assignFormula(cn, "1.234");
                assertEquals ("1.234", s.getFormula(cn));
                Value v = s.getValue(cn);
                assertNotNull(v);
                assertTrue (v instanceof NumericValue);
                NumericValue nv = (NumericValue)v;
                assertEquals (1.234, nv.getDouble(), 0.0001);
        }
        
        @Test
        public final void testParsingError() {
                
                final Spreadsheet s = new Spreadsheet();

                CellName cn = new CellName("b2");
                assertNull (s.getFormula(cn));
                assertNull (s.getValue(cn));
                boolean thrown = false;
                try {
                        s.assignFormula(cn, "1.23.4");
                } catch (ExpressionParseError e) {
                        thrown = true;
                }
                assertTrue (thrown);
                
                assertNull (s.getFormula(cn));
                Value v = s.getValue(cn);
                assertNull(v);
        }

}