/// <summary>
 /// 
 /// </summary>
 /// <param name="isValid"></param>
 /// <param name="normalize"></param>
 /// <param name="version"></param>
 public Spreadsheet (Func<string, bool> isValid, Func<string, string> normalize, string version) 
     : base(isValid, normalize, version)
 {
     allCells = new Dictionary<string, Cell>();
     graph = new DependencyGraph();
     isChanged = false;
 }

 /// <summary>
 /// Constructor which takes in delegate values from the user
 /// </summary>
 /// <param name="isValid">Validity delegate</param>
 /// <param name="normalize">Normalization delegate</param>
 /// <param name="version">Version of spreadsheet</param>
 public Spreadsheet(Func<string, bool> isValid, Func<string, string> normalize, string version)
     : base(isValid, normalize, version)
 {
     dependency_graph = new DependencyGraph();
     cell = new Dictionary<String, Cell>();
     Changed = false;            //Test
 }

 /// <summary>
 /// Contructs a new spreadsheet, (4 arguments from user)
 /// </summary>
 public Spreadsheet(string path, Func<string, bool> isValid, Func<string, string> normalize, string version)
     : base(isValid, normalize, version)
 {
     cells = new Dictionary<string, Cell>();
     dependencyGraph = new DependencyGraph();
     GetSavedVersion(path);
 }

 public void AddTest2Test()
 {
     DependencyGraph t = new DependencyGraph();
     t.AddDependency("A3", "A2");
     t.AddDependency("A1", "A2");
     Assert.AreEqual(2, t.Size);
 }

 /// <summary>
 /// Reads a saved spreadsheet from file and uses it to construct a new spreadsheet. 
 /// The spreadsheet uses the provided validity delegate, normalization delegate and verson. 
 /// </summary>
 /// <param name="file"></param>
 /// <param name="isValid"></param>
 /// <param name="normalize"></param>
 /// <param name="version"></param>
 public Spreadsheet(string file, Func<string, bool> isValid, Func<string, string> normalize, string version)
     : base(isValid, normalize, version)
 {
     spreadsheet = new Dictionary<string, Cell>();
     dependencyGraph = new DependencyGraph();
     ReadFile(file);
 }

 public void EmptyTest11()
 {
     DependencyGraph t = new DependencyGraph();
     t.AddDependency("x", "y");
     Assert.AreEqual(t.Size, 1);
     t.RemoveDependency("x", "y");
     t.RemoveDependency("x", "y");
 }

 public void EmptyTest10()
 {
     DependencyGraph t = new DependencyGraph();
     t.AddDependency("x", "y");
     Assert.AreEqual(1, t["y"]);
     t.RemoveDependency("x", "y");
     Assert.AreEqual(0, t["y"]);
 }

 public Spreadsheet()
     : base(s=>true, s => s, "default")
 {
     this.IsValid = IsValid;
     this.Normalize = Normalize;
     dg = new DependencyGraph();
     cells = new HashSet<Cell>();
     change = false;
 }

 public void EmptyTest12()
 {
     DependencyGraph t = new DependencyGraph();
     t.AddDependency("x", "y");
     Assert.AreEqual(t.Size, 1);
     t.RemoveDependency("x", "y");
     t.ReplaceDependents("x", new HashSet<string>());
     t.ReplaceDependees("y", new HashSet<string>());
 }

 public void AddTest1Test()
 {
     DependencyGraph t = new DependencyGraph();
     t.AddDependency("A1", "A2");
     t.AddDependency("A1", "A3");
     t.RemoveDependency("A1", "A2");
     Assert.AreEqual(1, t.Size);
     t.AddDependency("A1", "A4");
     Assert.AreEqual(2, t.Size);
     HashSet<string> test = new HashSet<string>();
     test.Add("A3");
     test.Add("A4");
     Assert.AreEqual(true, test.SetEquals(t.GetDependents("A1")));
 }

 public void PrivateDataTest()
 {
     try
     {
         DependencyGraph dg = new DependencyGraph();
         dg.AddDependency("a", "b");
         dg.AddDependency("a", "c");
         ICollection<string> temp = (ICollection<string>)dg.GetDependents("a");
         temp.Add("d");
         Assert.IsTrue(new HashSet<string> { "b", "c", "d" }.SetEquals(temp));
         Assert.IsTrue(new HashSet<string> { "b", "c" }.SetEquals(dg.GetDependents("a")));
     }
     catch (Exception e)
     {
         if (!(e is NotSupportedException || e is InvalidCastException))
             Assert.Fail();
     }
 }

        /// <summary>
        /// Opens a saved spreadsheet and puts it back together
        /// </summary>
        /// <param name="myPath"></param>
        /// <param name="myValid"></param>
        /// <param name="myNormalize"></param>
        /// <param name="myVersion"></param>
        public Spreadsheet(string myPath, Func<string, bool> myValid, Func<string, string> myNormalize, string myVersion)
            : base(myValid, myNormalize, myVersion)
        {
            mySpreadsheet = new Dictionary<string, Cell>();
            dependentCells = new DependencyGraph();
            //GetSavedVersion(myPath);
            using (XmlReader myReader = XmlReader.Create(myPath))
            {
                string myContent = null;
                while (myReader.Read())
                {

                    if (myReader.IsStartElement())
                    {
                        switch (myReader.Name)
                        {
                            case "Version Information":
                                break;
                            case "cell":
                                break;

                            case "name":

                                myReader.Read();
                                myContent = myReader.Value;
                                break;
                            case "contents":
                                myReader.Read();
                                HashSet<string> mySet = new HashSet<string>();
                                //Foreach look sets the cell contents and evaluates the value of any direct or indirect dependents
                                foreach (string s in SetContentsOfCell(myContent, myReader.Value))
                                {
                                    mySpreadsheet[s].myValue = myEvaluate(s);
                                }
                                break;

                        }
                    }
                }
            }
            Changed = false;
        }

        /// <summary>
        /// Constructs an abstract spreadsheet by recording its variable validity test,
        /// its normalization method, and its version information.  The variable validity
        /// test is used throughout to determine whether a string that consists of one or
        /// more letters followed by one or more digits is a valid cell name.  The variable
        /// equality test should be used thoughout to determine whether two variables are
        /// equal.
        /// </summary>
        public Spreadsheet(string filePath, Func<string, bool> isValid, Func<string, string> normalize, string version)
            : base(isValid, normalize, version)
        {
            //read save file from filePath
            spreadsheet = new Dictionary<string, Cell> { };
            dependency_graph = new DependencyGraph();
            has_changed = false;
            try
            {
                using (XmlReader read_file = XmlReader.Create(filePath))
                {
                    if (GetSavedVersion(filePath) != version)
                    {
                        throw new SpreadsheetReadWriteException("File versions are not the same.");
                    }
                    try
                    {
                        string cell_name = "";
                        while (read_file.Read())
                        {
                            if (read_file.IsStartElement())
                            {
                                switch (read_file.Name)
                                {
                                    case "spreadsheet":
                                        break;
                                    case "cell":
                                        break;
                                    case "name":
                                        read_file.Read();
                                        cell_name = read_file.Value;
                                        break;
                                    case "contents":
                                        read_file.Read();
                                        try
                                        {
                                            SetContentsOfCell(cell_name, read_file.Value);
                                        }
                                        catch (Exception ex)
                                        {
                                            throw new SpreadsheetReadWriteException(ex.Message);
                                        }
                                        break;
                                }
                            }
                        }
                    }
                    catch
                    {

                        throw new SpreadsheetReadWriteException("Error while reading from file");
                    }
                }
            }
            catch (Exception ex)
            {
                throw new SpreadsheetReadWriteException(ex.Message);
            }
            has_changed = false;
        }

 /// <summary>
 /// The three argument constructor; this allows the user to provide a validity delegate, a normalization delegate, 
 /// and a version (third parameter).
 /// </summary>
 /// <param name="isValid"></param>
 /// <param name="normalize"></param>
 /// <param name="version"></param>
 public Spreadsheet(Func<string, bool> isValid, Func<string, string> normalize, string version)
     : base(isValid, normalize, version)
 {
     //Setup data structures that keep track of which cells depend on which, and the association between cells and cell names.
     dependencies = new DependencyGraph();
     cells = new SortedDictionary<string, Cell>();
     Changed = false;
 }

 public void EmptyTest8()
 {
     DependencyGraph t = new DependencyGraph();
     t.AddDependency("a", "b");
 }

 public void EmptyTest7()
 {
     DependencyGraph t = new DependencyGraph();
     t.RemoveDependency("a", "b");
     Assert.AreEqual(0, t.Size);
 }

 public void EmptyTest6()
 {
     DependencyGraph t = new DependencyGraph();
     Assert.AreEqual(0, t["a"]);
 }

 public void EmptyTest5()
 {
     DependencyGraph t = new DependencyGraph();
     Assert.IsFalse(t.GetDependents("a").GetEnumerator().MoveNext());
 }

 public void EmptyTest3()
 {
     DependencyGraph t = new DependencyGraph();
     Assert.IsFalse(t.HasDependents("a"));
 }

        public void StressTest15()
        {
            // Dependency graph
            DependencyGraph t = new DependencyGraph();

            // A bunch of strings to use
            const int SIZE = 100;
            string[] letters = new string[SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                letters[i] = ("" + (char)('a' + i));
            }

            // The correct answers
            HashSet<string>[] dents = new HashSet<string>[SIZE];
            HashSet<string>[] dees = new HashSet<string>[SIZE];
            for (int i = 0; i < SIZE; i++)
            {
                dents[i] = new HashSet<string>();
                dees[i] = new HashSet<string>();
            }

            // Add a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 1; j < SIZE; j++)
                {
                    t.AddDependency(letters[i], letters[j]);
                    dents[i].Add(letters[j]);
                    dees[j].Add(letters[i]);
                }
            }

            // Remove a bunch of dependencies
            for (int i = 0; i < SIZE; i++)
            {
                for (int j = i + 2; j < SIZE; j += 2)
                {
                    t.RemoveDependency(letters[i], letters[j]);
                    dents[i].Remove(letters[j]);
                    dees[j].Remove(letters[i]);
                }
            }

            // Replace a bunch of dependees
            for (int i = 0; i < SIZE; i += 4)
            {
                HashSet<string> newDees = new HashSet<String>();
                for (int j = 0; j < SIZE; j += 7)
                {
                    newDees.Add(letters[j]);
                }
                t.ReplaceDependees(letters[i], newDees);

                foreach (string s in dees[i])
                {
                    dents[s[0] - 'a'].Remove(letters[i]);
                }

                foreach (string s in newDees)
                {
                    dents[s[0] - 'a'].Add(letters[i]);
                }

                dees[i] = newDees;
            }

            // Make sure everything is right
            for (int i = 0; i < SIZE; i++)
            {
                Assert.IsTrue(dents[i].SetEquals(new HashSet<string>(t.GetDependents(letters[i]))));
                Assert.IsTrue(dees[i].SetEquals(new HashSet<string>(t.GetDependees(letters[i]))));
            }
        }