using Perforce.P4;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using NLog;

namespace p4api.net.unit.test
{
    /// <summary>
    ///This is a test class for RepositoryTest and is intended
    ///to contain all RepositoryTest Unit Tests
    ///</summary>
    [TestClass()]
    public partial class RepositoryTest
    {
        private static Logger logger = LogManager.GetCurrentClassLogger();
        public TestContext TestContext { get; set; }

        [TestInitialize]
        public void SetupTest()
        {
            Utilities.LogTestStart(TestContext);
        }
        [TestCleanup]
        public void CleanupTest()
        {
            Utilities.LogTestFinish(TestContext);
        }

        String TestDir = "c:\\MyTestDir";

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for GetDepotFiles
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetDepotFilesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<FileSpec> target = rep.GetDepotFiles(lfs, null);
                        Assert.IsNotNull(target);
                        bool foundit = false;
                        foreach (FileSpec f in target)
                        {
                            if (f.DepotPath.Path == "//depot/MyCode/ReadMe.txt")
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFilesInUnloaded
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetDepotFilesInUloadedTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Depot depot = new Depot("Unloaded", DepotType.Unload, DateTime.Now, null, "admin",
                            "desc", ".p4s", "Unloaded/...", "//Unloaded/1", null);
                        depot.Id = "Unloaded";
                        depot.Type = DepotType.Unload;
                        rep.CreateDepot(depot);

                        Options options = new Options();
                        options["-c"] = "admin_space2";
                        P4Command cmd = new P4Command(con, "unload", true, null);
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        GetDepotFilesCmdOptions opts =
                            new GetDepotFilesCmdOptions(GetDepotFilesCmdFlags.InUnloadDepot, 0);

                        FileSpec fs = new FileSpec(new DepotPath("//Unloaded/..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<FileSpec> target = rep.GetDepotFiles(lfs, opts);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.AreEqual(target[0].DepotPath.Path,
                            "//Unloaded/client/admin_space2.ckp");

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }


        /// <summary>
        ///A test for GetDepotFilesInArchiveTest
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetDepotFilesInArchiveTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Depot depot = new Depot("Archive", DepotType.Archive, DateTime.Now, null, "admin",
                            "desc", ".p4s", "Archive/...", "//Archive/1", null);
                        depot.Id = "Archive";
                        depot.Type = DepotType.Archive;
                        rep.CreateDepot(depot);

                        Options options = new Options();
                        options["-D"] = "Archive";

                        P4Command cmd = new P4Command(con, "archive", true, "//depot/TheirCode/...");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch (P4Exception)
                        {

                        }

                        GetDepotFilesCmdOptions opts =
                            new GetDepotFilesCmdOptions(GetDepotFilesCmdFlags.InArchiveDepots, 0);

                        FileSpec fs = new FileSpec(new DepotPath("//Archive/..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<FileSpec> target = rep.GetDepotFiles(lfs, opts);

                        Assert.IsNotNull(target);

                        Assert.AreEqual(target[0].DepotPath.Path,
                                "//Archive/depot/TheirCode/Silly.bmp");
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir, resetDepot: true, unicode: unicode);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetArchiveFileActionTestA
        ///</summary>
        [TestMethod()]
        public void GetArchiveFileActionTestA()
        {
            GetArchiveFileActionTest(false);
        }

        /// <summary>
        ///A test for GetArchiveFileActionTestU
        ///</summary>
        [TestMethod()]
        public void GetArchiveFileActionTestU()
        {
            GetArchiveFileActionTest(true);
        }

        /// <summary>
        ///A test for GetArchiveFileActionTest
        ///</summary>
        public void GetArchiveFileActionTest(bool unicode)
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    Depot depot = new Depot("Archive", DepotType.Archive, DateTime.Now, null, "admin",
                        "desc", ".p4s", "Archive/...", "//Archive/1", null);
                    depot.Id = "Archive";
                    depot.Type = DepotType.Archive;
                    rep.CreateDepot(depot);

                    Options options = new Options();
                    options["-D"] = "Archive";

                    P4Command cmd = new P4Command(con, "archive", true, "//depot/TheirCode/...");
                    try
                    {
                        cmd.Run(options);
                    }
                    catch (P4Exception)
                    {

                    }

                    FileSpec fs = new FileSpec(new DepotPath("//depot/TheirCode/Silly.bmp"), null);
                    IList<FileSpec> lfs = new List<FileSpec>();
                    lfs.Add(fs);

                    IList<FileMetaData> fmd = rep.GetFileMetaData(lfs, null);
                    Assert.AreEqual(fmd[0].HeadAction, FileAction.Archive);
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir, resetDepot: true, unicode: unicode);
            }
        }

        /// <summary>
        ///A test for GetDepotFilesInRangeTest
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetDepotFilesInRangeTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        GetDepotFilesCmdOptions opts =
                            new GetDepotFilesCmdOptions(GetDepotFilesCmdFlags.AllRevisions, 0);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/..."),
                            new VersionRange(new ChangelistIdVersion(1), new ChangelistIdVersion(3)));

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<FileSpec> target = rep.GetDepotFiles(lfs, opts);

                        Assert.IsNotNull(target);

                        if (!unicode)
                        {
                            Assert.AreEqual(target.Count, 5);
                            Assert.AreEqual(target[0].DepotPath.Path,
                                     "//depot/MyCode/pup.txt");
                        }
                        else
                        {
                            Assert.AreEqual(target.Count, 3);
                            Assert.AreEqual(target[0].DepotPath.Path,
                                "//depot/MyCode/ReadMe.txt");
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }


        /// <summary>
        ///A test for GetDepotFilesNotDeletedTest
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetDepotFilesNotDeletedTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        // sync -f to avoid a cant clobber error
                        rep.Connection.Client.SyncFiles(new SyncFilesCmdOptions(SyncFilesCmdFlags.Force),
                            new FileSpec(new DepotPath("//depot/...")));

                        // schedule file for delete
                        FileSpec toFile = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"));
                        Options deleteOptions = new Options(DeleteFilesCmdFlags.None, -1);
                        IList<FileSpec> oldfiles = con.Client.DeleteFiles(deleteOptions, toFile);

                        Assert.AreEqual(1, oldfiles.Count);

                        //submit file
                        SubmitCmdOptions submitOpts = new SubmitCmdOptions(SubmitFilesCmdFlags.None, 0, null,
                          "submitted", null);
                        rep.Connection.Client.SubmitFiles(submitOpts, toFile);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/..."), null);
                        GetDepotFilesCmdOptions opts =
                            new GetDepotFilesCmdOptions(GetDepotFilesCmdFlags.NotDeleted, 0);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<FileSpec> target = rep.GetDepotFiles(lfs, opts);

                        Assert.IsNotNull(target);

                        if (!unicode)
                        {
                            Assert.AreEqual(target.Count, 7);
                            Assert.AreEqual(target[0].DepotPath.Path,
                                     "//depot/MyCode/pup.txt");
                        }
                        else
                        {
                            Assert.AreEqual(target.Count, 11);
                            Assert.AreEqual(target[0].DepotPath.Path,
                                "//depot/Modifiers/ReadMe.txt");
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFiles job094897
        ///</summary>
        [TestMethod()]
        public void GetDepotFilesjob094897Test()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    //Listing of files in the Depot
                    List<FileSpec> fileListRequest = new List<FileSpec>() { new FileSpec(new DepotPath("//depot/..."), null) };

                    //Returns 8 files
                    List<FileSpec> files = (List<FileSpec>)rep.GetDepotFiles(fileListRequest, null);

                    //Suppress the file headings
                    GetFileContentsCmdOptions fileRequestOptions = new GetFileContentsCmdOptions(GetFileContentsCmdFlags.Suppress, null);

                    //Get the 1st text file
                    var fileX = rep.GetFileContentsEx(new List<FileSpec>()
                        { files[1] }, fileRequestOptions);

                    //Get the 2nd text file
                    var fileY = rep.GetFileContentsEx(new List<FileSpec>() {
                            files[3] }, fileRequestOptions);

                    Assert.IsFalse(fileY[0].ToString().Contains("Don't"));
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for GetDepotFiles job095001
        ///</summary>
        [TestMethod()]
        public void GetDepotFilesjob095001Test()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";



            Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    //Listing of files in the Depot
                    List<FileSpec> fileListRequest = new List<FileSpec>() { new FileSpec(new DepotPath("//depot/..."), null) };

                    //Returns 8 files
                    List<FileSpec> files = (List<FileSpec>)rep.GetDepotFiles(fileListRequest, null);

                    //Suppress the file headings
                    GetFileContentsCmdOptions fileRequestOptions = new GetFileContentsCmdOptions(GetFileContentsCmdFlags.Suppress, null);

                    //Get the 1st text file
                    var fileX = rep.GetFileContents(new List<FileSpec>()
                        { files[1] }, fileRequestOptions);

                    //Get the 2nd text file
                    var fileY = rep.GetFileContents(new List<FileSpec>() {
                            files[3] }, fileRequestOptions);

                    Assert.IsFalse(fileY[0].Contains("Don't"));

                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
            unicode = !unicode;
        }

        /// <summary>
        ///A test for GetDepotFiles job095131
        ///</summary>
        [TestMethod()]
        public void GetDepotFilesjob095131Test()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";



            Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    //Listing of files in the Depot
                    List<FileSpec> fileListRequest = new List<FileSpec>() { new FileSpec(new DepotPath("//depot/MyCode2/..."), null) };

                    //Returns 6 files
                    List<FileSpec> files = (List<FileSpec>)rep.GetDepotFiles(fileListRequest, null);

                    //Suppress the file headings
                    GetFileContentsCmdOptions fileRequestOptions = new GetFileContentsCmdOptions(GetFileContentsCmdFlags.Suppress, null);

                    //Get a text file
                    var fileX = rep.GetFileContents(new List<FileSpec>()
                        { files[4] }, fileRequestOptions);

                    //Get a deleted file
                    var fileY = rep.GetFileContents(new List<FileSpec>() {
                            files[1] }, fileRequestOptions);

                    // behavior in job095131 will result in fileY having the same
                    // file contents as FileX, when it should be ""
                    Assert.IsFalse(fileY[0].Contains("Don't"));

                    //Get a text file
                    fileX = rep.GetFileContents(new List<FileSpec>()
                        { files[4] }, fileRequestOptions);

                    //Get a binary file
                    var fileZ = rep.GetFileContents(new List<FileSpec>()
                        { files[5] }, fileRequestOptions);

                    // behavior in job095131 will result in fileZ having the same
                    // file contents as FileX, when it should be ""
                    Assert.IsFalse(fileZ[0].Contains("Don't"));
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
            unicode = !unicode;
        }

        /// <summary>
        ///A test for GetOpenedFiles
        ///</summary>
        [TestMethod()]
        public void GetOpenedFilesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 12, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<File> target = rep.GetOpenedFiles(lfs, null);
                        Assert.IsNotNull(target);
                        bool foundit = false;
                        foreach (File f in target)
                        {
                            if (f.DepotPath.Path == "//depot/MyCode/NewFile.txt")
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);

                        Options opts = new Options();
                        opts["-c"] = "default";
                        opts["-C"] = con.Client.Name;
                        target = rep.GetOpenedFiles(null, opts);
                        Assert.IsNotNull(target);
                        if (!unicode)
                        {
                            Assert.AreEqual(target.Count, 3);
                        }
                        else
                        {
                            Assert.AreEqual(target.Count, 7);
                        }

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetOpenedFilesShortOutput
        ///</summary>
        [TestMethod()]
        public void GetOpenedFilesShortOutputTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 12, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        // use -a
                        GetOpenedFilesOptions opts = new GetOpenedFilesOptions(GetOpenedFilesCmdFlags.AllClients,
                            null, null, null, 0);

                        IList<File> target = new List<File>();
                        target = rep.GetOpenedFiles(lfs, opts);

                        // file type is returned with p4 opened -a
                        Assert.IsNotNull(target[0].Type);

                        // use -a -s
                        opts = new GetOpenedFilesOptions(GetOpenedFilesCmdFlags.ShortOutput |
                                GetOpenedFilesCmdFlags.AllClients, null, null, null, 0);
                        target = rep.GetOpenedFiles(lfs, opts);

                        // file type is not returned with p4 opened -a -s
                        Assert.IsNull(target[0].Type);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetOpenedFilesExclusive
        ///</summary>
        [TestMethod()]
        public void GetOpenedFilesExclusiveTest()
        {
            // TODO: add distributed environment to utilities setup
            // in order to test the success path of this operation
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 12, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);
                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                        Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                        FileSpec fs = new FileSpec(new DepotPath("//..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        // open a file with exclusive lock
                        FileSpec toOpen = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"),
                            null, null, null);
                        EditCmdOptions editOpts = new EditCmdOptions(EditFilesCmdFlags.None, 0,
                            new FileType(BaseFileType.Text, FileTypeModifier.ExclusiveOpen));
                        rep.Connection.Client.EditFiles(editOpts, toOpen);

                        GetOpenedFilesOptions opts = new GetOpenedFilesOptions(GetOpenedFilesCmdFlags.Exclusive,
                            null, null, null, 0);
                        IList<File> target = new List<File>();
                        try
                        {
                            target = rep.GetOpenedFiles(lfs, opts);

                        }
                        // p4 opened -x will fail on a non-distributed environment
                        catch (P4Exception ex)
                        {
                            Assert.AreEqual(805379732, ex.ErrorCode,
                                "This command is only supported in a distributed configuration.\n");
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetadata
        ///</summary>
        [TestMethod()]
        public void GetFileMetadataTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode2/ReadMe.txt"), null);
                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        Options ops = new Options();
                        ops["-Oa"] = null;

                        DepotPath movedfile = null;
                        bool ismapped = false;
                        bool shelved = false;
                        FileAction headaction = FileAction.None;
                        int headchange = -1;
                        int headrev = -1;
                        FileType headtype = new FileType("none");
                        DateTime headtime = DateTime.MinValue;
                        DateTime headmodtime = DateTime.MinValue;
                        int movedrev = -1;
                        int haverev = -1;
                        string desc = null;
                        string digest = null;
                        int filesize = -1;
                        FileAction action = FileAction.None;
                        FileType type = null;
                        string actionowner = null;
                        int change = -1;
                        bool resolved = false;
                        bool unresolved = false;
                        bool reresolvable = false;
                        int otheropen = -1;
                        List<string> otheropenuserclients = new List<string>();
                        bool otherlock = false;
                        List<string> otherlockuserclients = new List<string>();
                        List<FileAction> otheractions = new List<FileAction>();
                        List<int> otherchanges = new List<int>();
                        bool ourlock = false;
                        List<FileResolveAction> resolverecords = new List<FileResolveAction>();
                        Dictionary<string, object> attributes = null;
                        Dictionary<string, object> attributedigests = null;
                        FileMetaData fmd = new FileMetaData
                 (
                 movedfile,
                 ismapped,
                 shelved,
                 headaction,
                 headchange,
                 headrev,
                 headtype,
                 headtime,
                 headmodtime,
                 movedrev,
                 haverev,
                 desc,
                 digest,
                 filesize,
                 action,
                 type,
                 actionowner,
                 change,
                 resolved,
                 unresolved,
                 reresolvable,
                 otheropen,
                 otheropenuserclients,
                 otherlock,
                 otherlockuserclients,
                 otheractions,
                 otherchanges,
                 ourlock,
                 resolverecords,
                 attributes,
                 attributedigests,
                 null, null, null, -1, null
                 );

                        IList<FileMetaData> target = rep.GetFileMetaData(lfs, ops);

                        int expected = 2;
                        int actual = target[0].HaveRev;
                        Assert.AreEqual(expected, actual);

                        if (unicode == false)
                            expected = 11;
                        else
                            expected = 10;
                        actual = target[0].HeadChange;
                        Assert.AreEqual(expected, actual);

                        bool isresolved = false;
                        bool actualres = target[0].Resolved;
                        Assert.AreEqual(isresolved, actualres);

                        bool foundit = false;
                        foreach (FileMetaData f in target)
                        {
                            if (f.Attributes.ContainsKey("1st")
                                &&
                                f.Attributes.ContainsValue("9999")
                                )
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);

                        foundit = false;
                        foreach (FileMetaData f in target)
                        {
                            if (f.OtherOpenUserClients.Contains("Alice@alice_space")
                                |
                                f.OtherOpenUserClients.Contains("alice@alice_space"))
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);

                        foundit = false;
                        foreach (FileMetaData f in target)
                        {
                            if (f.ActionOwner.Contains("admin"))
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);

                        foundit = false;
                        foreach (FileMetaData f in target)
                        {
                            if (f.Action == FileAction.Integrate)
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);

                        // a test for the obsoleted options
#pragma warning disable 618
                        ops = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.Opened,
                                  null, null, 0, null, null);
#pragma warning restore 618

                        // if the options were not obsoleted correctly
                        // they would be returned with a count of 0
                        // and contain no flags or arguements
                        Assert.AreEqual(ops.Count, 1);
                        Assert.IsTrue(ops.ContainsKey("-Ro"));
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetadataStaleRevA
        ///</summary>
        [TestMethod()]
        public void GetFileMetadataStaleRevTestA()
        {
            GetFileMetadataStaleRevTest(false);
        }

        /// <summary>
        ///A test for GetFileMetadataStaleRevU
        ///</summary>
        [TestMethod()]
        public void GetFileMetadataStaleRevTestU()
        {
            GetFileMetadataStaleRevTest(true);
        }

        /// <summary>
        ///A test for GetFileMetadataStaleRev
        ///</summary>
        public void GetFileMetadataStaleRevTest(bool unicode)
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
            var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
            var adminSpace = System.IO.Path.Combine(clientRoot, "admin_space");
            System.IO.Directory.CreateDirectory(adminSpace);

            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                    Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                    if (unicode)
                    {
                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), new Revision(0));
                        FileSpec fs2 = new FileSpec(new DepotPath("//depot/Modifiers/Text.txt"), new Revision(1));

                        // sync files to 0/1 and 1/2
                        rep.Connection.Client.SyncFiles(new SyncFilesCmdOptions(SyncFilesCmdFlags.Force), fs);
                        rep.Connection.Client.SyncFiles(new SyncFilesCmdOptions(SyncFilesCmdFlags.Force), fs2);

                        fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        fs2 = new FileSpec(new DepotPath("//depot/Modifiers/Text.txt"), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);
                        lfs.Add(fs2);

                        // check for stale revs and IsStale
                        IList<FileMetaData> target = rep.GetFileMetaData(lfs, null);
                        Assert.IsTrue(target[0].HaveRev < target[0].HeadRev);
                        Assert.IsTrue(target[0].IsStale);
                        Assert.IsTrue(target[1].HaveRev < target[1].HeadRev);
                        Assert.IsTrue(target[1].IsStale);
                    }
                    else
                    {
                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), new Revision(0));
                        FileSpec fs2 = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), new Revision(1));

                        // sync files to 0/1 and 1/2
                        rep.Connection.Client.SyncFiles(new SyncFilesCmdOptions(SyncFilesCmdFlags.Force), fs);
                        rep.Connection.Client.SyncFiles(new SyncFilesCmdOptions(SyncFilesCmdFlags.Force), fs2);

                        fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        fs2 = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);
                        lfs.Add(fs2);

                        // check for stale revs and IsStale
                        IList<FileMetaData> target = rep.GetFileMetaData(lfs, null);
                        Assert.IsTrue(target[0].HaveRev < target[0].HeadRev);
                        Assert.IsTrue(target[0].IsStale);
                        Assert.IsTrue(target[1].HaveRev < target[1].HeadRev);
                        Assert.IsTrue(target[1].IsStale);
                    }
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataFileCount
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataFileCountTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        GetFileMetaDataCmdOptions opts =
                            new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.DateSort,
                           null, null, 1, null, null, null);

                        FileSpec fs = new FileSpec(new DepotPath("//Depot/..."), null);

                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        if (unicode)
                        {
                            Assert.AreEqual(target[0].TotalFileCount, 14);
                        }
                        else
                        {
                            Assert.AreEqual(target[0].TotalFileCount, 9);
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataInUnloaded
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataInUnloadedTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Depot depot = new Depot("Unloaded", DepotType.Unload, DateTime.Now, null, "admin",
                            "desc", ".p4s", "Unloaded/...", "//Depot/1", null);
                        depot.Id = "Unloaded";
                        depot.Type = DepotType.Unload;
                        rep.CreateDepot(depot);

                        Options options = new Options();
                        options["-c"] = "admin_space2";
                        P4Command cmd = new P4Command(con, "unload", true, null);
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.InUnloadDepot,
                            null, null, 0, null, null, null);

                        FileSpec fs = new FileSpec(new DepotPath("//Unloaded/..."), null);

                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.AreEqual(target[0].DepotPath.Path,
                            "//Unloaded/client/admin_space2.ckp");
                        Assert.IsTrue(target[0].IsInDepot);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataAttribute
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataAttributeTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);
                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                        Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        rep.Connection.Client.EditFiles(null, fs);

                        Options options = new Options();
                        options["-n"] = "attribute";
                        options["-v"] = "1024";

                        P4Command cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        SubmitCmdOptions submitOpts = new SubmitCmdOptions(SubmitFilesCmdFlags.None, 0, null,
                            "submitted", null);
                        rep.Connection.Client.SubmitFiles(submitOpts, fs);

                        GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.Attributes,
                            null, null, 0, null, null, null);

                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.IsTrue(target[0].Attributes.ContainsKey("attribute"));
                        object value;
                        target[0].Attributes.TryGetValue("attribute", out value);
                        Assert.AreEqual(value, "1024");

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataAttributeDigest
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataAttributeDigestTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);
                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                        Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        rep.Connection.Client.EditFiles(null, fs);

                        Options options = new Options();
                        options["-n"] = "attribute";
                        options["-v"] = "1024";

                        P4Command cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        options["-n"] = "anotherone";
                        options["-v"] = "1024";

                        cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        SubmitCmdOptions submitOpts = new SubmitCmdOptions(SubmitFilesCmdFlags.None, 0, null,
                            "submitted", null);
                        rep.Connection.Client.SubmitFiles(submitOpts, fs);

                        GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.AttributeDigest,
                            null, null, 0, null, null, null);

                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.IsTrue(target[0].AttributeDigests.ContainsKey("attribute"));
                        object value;
                        target[0].AttributeDigests.TryGetValue("attribute", out value);
                        Assert.AreEqual(value, "021BBC7EE20B71134D53E20206BD6FEB");

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataAttributeHex
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataAttributeHexTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);
                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                        Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        rep.Connection.Client.EditFiles(null, fs);

                        Options options = new Options();
                        options["-n"] = "attribute";
                        options["-v"] = "1024";

                        P4Command cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        SubmitCmdOptions submitOpts = new SubmitCmdOptions(SubmitFilesCmdFlags.None, 0, null,
                            "submitted", null);
                        rep.Connection.Client.SubmitFiles(submitOpts, fs);

                        GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.HexAttributes,
                            null, null, 0, null, null, null);

                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.IsTrue(target[0].Attributes.ContainsKey("attribute"));
                        object value;
                        target[0].Attributes.TryGetValue("attribute", out value);
                        Assert.AreEqual(value, "31303234");

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataAttributePattern
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataAttributePatternTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);
                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                        Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        rep.Connection.Client.EditFiles(null, fs);

                        Options options = new Options();
                        options["-n"] = "attribute";
                        options["-v"] = "1024";

                        P4Command cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        options["-n"] = "anotherone";
                        options["-v"] = "1024";

                        cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        options["-n"] = "anotheroney";
                        options["-v"] = "1024";

                        cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        SubmitCmdOptions submitOpts = new SubmitCmdOptions(SubmitFilesCmdFlags.None, 0, null,
                            "submitted", null);
                        rep.Connection.Client.SubmitFiles(submitOpts, fs);

                        GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.Attributes,
                            null, null, 0, null, null, "anotherone");

                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.IsTrue(target[0].Attributes.ContainsKey("anotherone"));
                        object value;
                        target[0].Attributes.TryGetValue("anotherone", out value);
                        Assert.AreEqual(value, "1024");
                        Assert.AreEqual(target[0].Attributes.Count, 1);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileMetaDataAttributePropagate
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void GetFileMetaDataAttributePropagateTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);
                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                        Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);
                        rep.Connection.Client.EditFiles(null, fs);

                        Options options = new Options();
                        options["-n"] = "attribute";
                        options["-v"] = "1024";

                        P4Command cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        options["-p"] = null;
                        options["-n"] = "anotherone";
                        options["-v"] = "1024";

                        cmd = new P4Command(con, "attribute", true, "//depot/MyCode/ReadMe.txt");
                        try
                        {
                            cmd.Run(options);
                        }
                        catch
                        {

                        }

                        SubmitCmdOptions submitOpts = new SubmitCmdOptions(SubmitFilesCmdFlags.None, 0, null,
                            "submitted", null);
                        rep.Connection.Client.SubmitFiles(submitOpts, fs);

                        GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.Attributes,
                            null, null, 0, null, null, null);

                        // get filemetadata for the file with a propagated attribute
                        IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.IsTrue(target[0].AttributesProp.ContainsKey("anotherone"));
                        object value;
                        target[0].AttributesProp.TryGetValue("anotherone", out value);
                        Assert.AreEqual(value, "");
                        rep.Connection.Client.EditFiles(null, fs);

                        // now do it while the file is open for edit
                        target = rep.GetFileMetaData(opts, fs);

                        Assert.IsNotNull(target);
                        Assert.AreEqual(target.Count, 1);
                        Assert.IsTrue(target[0].OpenAttributes.ContainsKey("anotherone"));
                        target[0].OpenAttributes.TryGetValue("anotherone", out value);
                        Assert.AreEqual(value, "1024");
                        Assert.IsTrue(target[0].OpenAttributesProp.ContainsKey("anotherone"));
                        target[0].OpenAttributesProp.TryGetValue("anotherone", out value);
                        Assert.AreEqual(value, "");
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for FileMetaDataToFileSpecEditTestjob059334
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void FileMetaDataToFileSpecEditTestjob059334A()
        {
            FileMetaDataToFileSpecEditTestjob059334(false);
        }

        /// <summary>
        ///A test for FileMetaDataToFileSpecEditTestjob059334
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void FileMetaDataToFileSpecEditTestjob059334U()
        {
            FileMetaDataToFileSpecEditTestjob059334(true);
        }

        /// <summary>
        ///A test for FileMetaDataToFileSpecEditTestjob059334
        ///</summary>
        public void FileMetaDataToFileSpecEditTestjob059334(bool unicode)
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);
                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    IList<FileSpec> FileSpecs = new List<FileSpec>();
                    FileSpec fs = new FileSpec(new DepotPath("//Depot/..."), null);

                    // force sync all of the files
                    SyncFilesCmdOptions opts = new SyncFilesCmdOptions(SyncFilesCmdFlags.Force);
                    FileSpecs = con.Client.SyncFiles(opts, fs);

                    // get the local files that exist in the workspace
                    string[] files = System.IO.Directory.GetFiles(@"c:\MyTestDir\admin_space", "*", System.IO.SearchOption.AllDirectories);

                    // turn them into a LocalSpecList
                    FileSpecs = FileSpec.LocalSpecList(files);

                    // get 
                    IList<FileMetaData> fmd = rep.GetFileMetaData(FileSpecs, null);

                    FileSpecs = new List<FileSpec>();

                    // convert the list of FileMetaData to a list of FileSpecs 
                    foreach (FileMetaData f in fmd)
                    {
                        FileSpecs.Add(f);
                    }

                    // attempting to edit the FileSpecs should fail since they
                    // contain versions
                    try
                    {
                        con.Client.EditFiles(FileSpecs, null);
                    }
                    catch (P4Exception ex)
                    {
                        // the error should be:
                        // A revision specification (# or @) cannot be used here.
                        Assert.AreEqual(ex.ErrorCode, P4ClientError.MsgDm_NoRev);
                    }

                    // send the FileSpecs as an UnversionedSpecList
                    FileSpecs = con.Client.EditFiles(FileSpec.UnversionedSpecList(FileSpecs), null);

                    Assert.IsNotNull(FileSpecs);
                    if (unicode)
                    {
                        Assert.AreEqual(FileSpecs.Count, 7);
                    }
                    else
                    {
                        Assert.AreEqual(FileSpecs.Count, 5);
                    }
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for GetFileMetaData job094926
        [TestMethod()]
        public void GetFileMetaDatajob094926Test()
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, 13, false);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);
                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);
                    Utilities.SetClientRoot(rep, TestDir, false, ws_client);

                    FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode/ReadMe.txt"), null);


                    GetFileMetaDataCmdOptions opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.None,
                        null, null, 0, null, null, null);

                    // get filemetadata for the file with a propagated attribute
                    IList<FileMetaData> target = rep.GetFileMetaData(opts, fs);

                    Assert.IsNotNull(target);
                    // there should be client data
                    Assert.IsNotNull(target[0].ClientPath);
                    Assert.IsTrue(target[0].IsInClient);
                    Assert.IsNotNull(target[0].ClientPath);

                    // the bug job094926 will result in a Path '<path>'
                    // is not under client's root '<client root>'. error
                    // because Os is passed without "-"
                    opts = new GetFileMetaDataCmdOptions(GetFileMetadataCmdFlags.ExcludeClientData,
                        null, null, 0, null, null, null);

                    // get filemetadata for the file with a propagated attribute
                    target = rep.GetFileMetaData(opts, fs);

                    Assert.IsNotNull(target);
                    // there should not be client data
                    Assert.IsNull(target[0].ClientPath);
                    Assert.IsFalse(target[0].IsInClient);
                    Assert.IsNull(target[0].ClientPath);
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for Getting historical filetypes from tagged output
        ///</summary>
        [TestMethod()]
        public void HistoricalFileTypesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 15, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);


                        if (unicode == false)
                        {
                            FileSpec fs = new FileSpec(new DepotPath("//depot/Filetypes/ctempobj"), null);
                            List<FileSpec> lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            FileMetaData fmd = new FileMetaData();
                            IList<FileMetaData> target = rep.GetFileMetaData(lfs, null);
                            FileType ft = new FileType("ctempobj");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/ctext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("ctext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/cxtext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("cxtext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/ktext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("ktext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/kxtext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("kxtext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/ltext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("ltext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/tempobj"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("tempobj");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/ubinary"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("ubinary");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/uresource"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("uresource");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/uxbinary"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("uxbinary");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/xbinary"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("xbinary");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/xltext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("xltext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/xtext"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("xtext");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/xtempobj"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("xtempobj");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/xutf16"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("xutf16");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                            fs = new FileSpec(new DepotPath("//depot/Filetypes/xutf8"), null);
                            lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            fmd = new FileMetaData();
                            target = rep.GetFileMetaData(lfs, null);
                            ft = new FileType("xutf8");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);

                        }

                        if (unicode == true)
                        {
                            FileSpec fs = new FileSpec(new DepotPath("//depot/Filetypes/xunicode"), null);
                            List<FileSpec> lfs = new List<FileSpec>();
                            lfs.Add(fs);
                            FileMetaData fmd = new FileMetaData();
                            IList<FileMetaData> target = rep.GetFileMetaData(lfs, null);
                            FileType ft = new FileType("xunicode");
                            Assert.AreEqual(target[0].HeadType.BaseType, ft.BaseType);
                            Assert.AreEqual(target[0].HeadType.Modifiers, ft.Modifiers);
                        }

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotDirs
        ///</summary>
        [TestMethod()]
        public void GetDepotDirsTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<String> dirs = new List<String>() { "//*" };
                        string dir = "//*/*";
                        dirs.Add(dir);

                        IList<String> target = rep.GetDepotDirs(dirs, null);

                        bool foundit = false;
                        foreach (string line in target)
                        {
                            if (line == "//depot/MyCode")
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFixes
        ///</summary>
        [TestMethod()]
        public void GetFixesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/..."), null);
                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        GetFixesCmdFlags flags = GetFixesCmdFlags.None;
                        int changelistId = 0;
                        string jobId = null;
                        int maxFixes = 2;
                        Options ops = new Options(flags, changelistId, jobId, maxFixes);

                        IList<Fix> target = rep.GetFixes(lfs, ops);

                        foreach (Fix fix in target)
                        {
                            string expected = "admin";
                            string actual = fix.UserName;
                            Assert.AreEqual(expected, actual);

                            expected = "admin_space";
                            actual = fix.ClientName;
                            Assert.AreEqual(expected, actual);

                            // these dates sometimes come out an hour off, possibly do
                            //  tho daylight savings times?
                            //if (unicode == false)
                            //{
                            //    string datestr = "12/2/2010 2:13:00 PM";
                            //    DateTime date = DateTime.Parse(datestr);
                            //    Assert.AreEqual(fix.Date, date);
                            //}
                            //else
                            //{
                            //    string udatestr = "12/2/2010 2:19:21 PM";
                            //    DateTime udate = DateTime.Parse(udatestr);
                            //    Assert.AreEqual(fix.Date, udate);
                            //}

                            expected = "job000001";
                            actual = fix.JobId;
                            Assert.AreEqual(expected, actual);

                            expected = "closed";
                            actual = fix.Status;
                            Assert.AreEqual(expected, actual);

                            FixAction left = FixAction.Fixed;
                            FixAction right = fix.Action;
                            Assert.AreEqual(left, right);

                            if (unicode == false)
                            {
                                int cl = 4;
                                int clpos = fix.ChangeId;
                                Assert.AreEqual(cl, clpos);
                            }
                            else
                            {
                                int ucl = 3;
                                int uclpos = fix.ChangeId;
                                Assert.AreEqual(ucl, uclpos);
                            }

                            jobId = "job000001";
                            maxFixes = 2;
                            ops = new Options(flags, changelistId, jobId, maxFixes);

                            target = rep.GetFixes(lfs, ops);

                            Assert.AreEqual(target.Count, 1);

                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileHistory
        ///</summary>
        [TestMethod()]
        public void GetFileHistoryTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 5, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/MyCode2/ReadMe.txt"), null);
                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        Options ops = new Options();
                        ops["-m"] = "2";

                        IList<FileHistory> target = rep.GetFileHistory(lfs, ops);

                        int expected = 2;
                        int actual = target[0].Revision;
                        Assert.AreEqual(expected, actual);

                        if (unicode == false)
                            expected = 11;
                        else
                            expected = 10;
                        actual = target[0].ChangelistId;
                        Assert.AreEqual(expected, actual);

                        expected = 30;
                        long actual10 = target[0].FileSize;
                        Assert.AreEqual(expected, actual10);

                        string expected11 = "C7DECE3DB80A73F3F53AF4BCF6AC0576";
                        string actual11 = target[0].Digest;
                        Assert.AreEqual(expected11, actual11);

                        string expected1 = "admin";
                        string actual1 = target[0].UserName;
                        Assert.AreEqual(expected1, actual1);

                        if (unicode == false)
                            expected1 = "submit without changes ";
                        else
                            expected1 = "submit with no changes ";
                        actual1 = target[0].Description;
                        Assert.AreEqual(expected1, actual1);

                        expected1 = "admin_space";
                        actual1 = target[0].ClientName;
                        Assert.AreEqual(expected1, actual1);

                        FileAction expected2 = FileAction.Edit;
                        FileAction actual2 = target[0].Action;
                        Assert.AreEqual(expected2, actual2);

                        int expected3 = 1;
                        int actual3 = target[1].Revision;
                        Assert.AreEqual(expected3, actual3);

                        if (unicode == false)
                            expected3 = 10;
                        else
                            expected3 = 8;
                        actual3 = target[1].ChangelistId;
                        Assert.AreEqual(expected3, actual3);

                        string expected4 = "admin";
                        string actual4 = target[1].UserName;
                        Assert.AreEqual(expected4, actual4);

                        expected4 = "branch to MyCode2 ";
                        actual4 = target[1].Description;
                        Assert.AreEqual(expected4, actual4);

                        expected4 = "admin_space";
                        actual4 = target[1].ClientName;
                        Assert.AreEqual(expected4, actual4);

                        FileAction expected5 = FileAction.Branch;
                        FileAction actual5 = target[1].Action;
                        Assert.AreEqual(expected5, actual5);


                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetCounters
        ///</summary>
        [TestMethod()]
        public void GetCountersTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<Counter> target = rep.GetCounters(null);
                        bool foundit = false;
                        foreach (Counter counter in target)

                        {
                            if (counter.Name == "deleteme"
                                &&
                                counter.Value == "44")
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsTrue(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetCounter
        ///</summary>
        [TestMethod()]
        public void GetCounterTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Counter target = rep.GetCounter("deleteme", null);
                        bool foundit = false;

                        if (target.Name == "deleteme"
                            &&
                            target.Value == "44")
                        {
                            foundit = true;
                        }
                        Assert.IsTrue(foundit);

                        // previous tests did not use options. Use both depricated
                        // misspelled options and then fixed options name to get
                        // and increment the deleteme counter.
                        CoutnerCmdOptions misspelledOpts = new CoutnerCmdOptions(CounterCmdFlags.Increment);
                        target = rep.GetCounter("deleteme", misspelledOpts);
                        foundit = false;

                        if (target.Name == "deleteme"
                            &&
                            target.Value == "45")
                        {
                            foundit = true;
                        }
                        Assert.IsTrue(foundit);

                        CounterCmdOptions Opts = new CounterCmdOptions(CounterCmdFlags.Increment);
                        target = rep.GetCounter("deleteme", Opts);
                        foundit = false;

                        if (target.Name == "deleteme"
                            &&
                            target.Value == "46")
                        {
                            foundit = true;
                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for DeleteCounter
        ///</summary>
        [TestMethod()]
        [DeploymentItem("p4api.net.dll")]
        public void DeleteCounterTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        rep.DeleteCounter("deleteme", null);

                        IList<Counter> target = rep.GetCounters(null);
                        bool foundit = false;
                        foreach (Counter counter in target)
                        {
                            if (counter.Name == "deleteme"
                                &&
                                counter.Value == "44")
                            {
                                foundit = true;
                                break;
                            }
                        }
                        Assert.IsFalse(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetProtectionTable
        ///</summary>
        [TestMethod()]
        public void GetProtectionTableTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<ProtectionEntry> target = rep.GetProtectionTable(null);

                        Assert.IsNotNull(target);
                        bool foundit = false;


                        foreach (ProtectionEntry pte in target)
                        {
                            if (pte.Mode == ProtectionMode.Admin
                                &&
                                pte.Type == EntryType.User
                                &&
                                pte.Name == "Alex"
                                &&
                                pte.Host == "*"
                                &&
                                pte.Path == "//MyCode2/ReadMe.txt")
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetProtectionTablejob079134A
        ///</summary>
        [TestMethod()]
        public void GetProtectionTableTestjob079134A()
        {
            GetProtectionTableTestjob079134(false);
        }

        /// <summary>
        ///A test for GetProtectionTablejob079134U
        ///</summary>
        [TestMethod()]
        public void GetProtectionTableTestjob079134U()
        {
            GetProtectionTableTestjob079134(true);
        }

        /// <summary>
        ///A test for GetProtectionTablejob079134
        ///</summary>
        public void GetProtectionTableTestjob079134(bool unicode)
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    IList<ProtectionEntry> target = rep.GetProtectionTable();

                    Assert.IsNotNull(target);
                    bool foundit = false;


                    foreach (ProtectionEntry pte in target)
                    {
                        if (pte.Mode == ProtectionMode.Admin
                            &&
                            pte.Type == EntryType.User
                            &&
                            pte.Name == "Alex"
                            &&
                            pte.Host == "*"
                            &&
                            pte.Path == "//MyCode2/ReadMe.txt")
                        {
                            foundit = true;
                            break;
                        }

                    }
                    Assert.IsTrue(foundit);

                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }
        /// <summary>
        ///A test for GetTriggerTable
        ///</summary>
        [TestMethod()]
        public void GetTriggerTableTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<Trigger> target = new List<Trigger>();

                        Options ops = new Options();


                        ops["-o"] = null;
                        target = rep.GetTriggerTable(ops);
                        Assert.IsNotNull(target);
                        bool foundit = false;


                        foreach (Trigger t in target)
                        {
                            if (t.Name == "change"
                                &&
                                t.Type == TriggerType.ChangeSubmit
                                &&
                                t.Path == "//depot/..."
                                &&
                                t.Command == "\"cmd %changelist%\""
                                &&
                                t.Order == 0)
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetTypeMap
        ///</summary>
        [TestMethod()]
        public void GetTypeMapTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<TypeMapEntry> target = new List<TypeMapEntry>();

                        Options ops = new Options();


                        target = rep.GetTypeMap();
                        Assert.IsNotNull(target);
                        bool foundit = false;


                        foreach (TypeMapEntry t in target)
                        {
                            if (t.FileType.BaseType.Equals(BaseFileType.Binary)
                                &&
                                t.FileType.Modifiers.HasFlag(FileTypeModifier.ExclusiveOpen)
                                &&
                                t.Path == "//depot/Modifiers/...")
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFormSpec
        ///</summary>
        [TestMethod()]
        public void GetFormSpecTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FormSpec target = new FormSpec();

                        Options ops = new Options();
                        ops["-o"] = null;

                        target = rep.GetFormSpec(ops, "change");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "branch");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "client");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "depot");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "group");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "job");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "label");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "spec");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "stream");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "triggers");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "typemap");

                        Assert.IsNotNull(target);

                        target = rep.GetFormSpec(ops, "user");

                        Assert.IsNotNull(target);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetSpecFieldDataType
        ///</summary>
        [TestMethod()]
        public void GetFieldDataTypeTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FormSpec target = new FormSpec();

                        Options ops = new Options();
                        ops["-o"] = null;

                        target = rep.GetFormSpec(ops, "job");

                        Assert.IsNotNull(target);

                        SpecFieldDataType type = target.GetSpecFieldDataType(target, "Job");

                        Assert.AreEqual(type, SpecFieldDataType.Word);

                        type = target.GetSpecFieldDataType(target, "Status");

                        Assert.AreEqual(type, SpecFieldDataType.Select);

                        type = target.GetSpecFieldDataType(target, "NotHere");

                        Assert.AreEqual(type, SpecFieldDataType.None);

                        type = target.GetSpecFieldDataType(target, "User");

                        Assert.AreEqual(type, SpecFieldDataType.Word);

                        type = target.GetSpecFieldDataType(target, "Date");

                        Assert.AreEqual(type, SpecFieldDataType.Date);

                        type = target.GetSpecFieldDataType(target, "Description");

                        Assert.AreEqual(type, SpecFieldDataType.Text);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetReviewers
        ///</summary>
        [TestMethod()]
        public void GetReviewersTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/..."), null);

                        List<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        IList<User> target = rep.GetReviewers(lfs, null);
                        Assert.IsNotNull(target);
                        bool foundit = false;

                        foreach (User u in target)
                        {
                            if ((u.Id == "Alex" | u.Id == "Алексей")
                                &&
                                (u.FullName == "Alexie Dumas" | u.FullName == "Алексей Дюма")
                                &&
                                (u.EmailAddress == "Alex@p4test.com" | u.EmailAddress == "alex@p4test.com"))
                            {
                                foundit = true;
                                break;
                            }
                        }

                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetProtectionEntries
        ///</summary>
        [TestMethod()]
        public void GetProtectionEntriesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<ProtectionEntry> target = new List<ProtectionEntry>();

                        Options ops = new Options();


                        ops["-u"] = "alex";
                        target = rep.GetProtectionEntries(null, ops);
                        Assert.IsNotNull(target);
                        bool foundit = false;


                        foreach (ProtectionEntry pte in target)
                        {
                            if (pte.Mode == ProtectionMode.Write
                                &&
                                pte.Type == EntryType.User
                                &&
                                pte.Name == "*"
                                &&
                                pte.Host == "*"
                                &&
                                pte.Path == "//...")
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetMaxProtectionAccessA
        ///</summary>
        [TestMethod()]
        public void GetMaxProtectionAccessTestA()
        {
            GetMaxProtectionAccessTest(false);
        }

        /// <summary>
        ///A test for GetMaxProtectionAccessU
        ///</summary>
        [TestMethod()]
        public void GetMaxProtectionAccessTestU()
        {
            GetMaxProtectionAccessTest(true);
        }

        /// <summary>
        ///A test for GetMaxProtectionAccess
        ///</summary>
        public void GetMaxProtectionAccessTest(bool unicode)
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    Options opts = new GetMaxProtectionAccessCmdOptions(
                        GetMaxProtectionAccessCmdFlags.AccessSummary, null, "Alex", null);

                    ProtectionMode target = rep.GetMaxProtectionAccess(null, opts);

                    Assert.AreEqual(target, ProtectionMode.Admin);

                    opts = new GetMaxProtectionAccessCmdOptions(
                        GetMaxProtectionAccessCmdFlags.AccessSummary, null, "nobody", null);

                    target = rep.GetMaxProtectionAccess(new List<FileSpec>()
                          {
                                  new FileSpec(new DepotPath("//..."), null, null, null)
                          }, opts);

                    Assert.AreEqual(target, ProtectionMode.Write);

                    opts = new GetMaxProtectionAccessCmdOptions(
                        GetMaxProtectionAccessCmdFlags.AccessSummary, "everyone", null, null);

                    target = rep.GetMaxProtectionAccess(new List<FileSpec>()
                          {
                                  new FileSpec(new DepotPath("c:\\MyTestDir\\admin_space\\Modifiers\\ReadMe.txt"), null, null, null)
                          }, opts);

                    Assert.AreEqual(target, ProtectionMode.None);

                    opts = new GetMaxProtectionAccessCmdOptions(
                        GetMaxProtectionAccessCmdFlags.AccessSummary, null, "admin", null);

                    target = rep.GetMaxProtectionAccess(new List<FileSpec>()
                          {
                                  new FileSpec(new DepotPath("//..."), null, null, null)
                          }, opts);

                    Assert.AreEqual(target, ProtectionMode.Super);
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for GetEqualsProtectionModesA
        ///</summary>
        [TestMethod()]
        public void GetEqualsProtectionModesA()
        {
            GetEqualsProtectionModesTest(false);
        }

        /// <summary>
        ///A test for GetEqualsProtectionModesU
        ///</summary>
        [TestMethod()]
        public void GetEqualsProtectionModesTestU()
        {
            GetEqualsProtectionModesTest(true);
        }

        /// <summary>
        ///A test for GetEqualsProtectionModes
        ///</summary>
        public void GetEqualsProtectionModesTest(bool unicode)
        {
            int checkpoint = unicode ? 17 : 18;
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, checkpoint, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    Options opts = new GetProtectionEntriesCmdOptions(
                        GetProtectionEntriesCmdFlags.AllUsers, null, null, null);

                    IList<ProtectionEntry> target = rep.GetProtectionEntries(null, opts);

                    Assert.AreEqual(target[4].Mode, ProtectionMode.ReadRights);
                    Assert.AreEqual(target[5].Mode, ProtectionMode.OpenRights);
                    Assert.AreEqual(target[6].Mode, ProtectionMode.BranchRights);
                    Assert.AreEqual(target[7].Mode, ProtectionMode.WriteRights);
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for GetExcludedProtectionsA
        ///</summary>
        [TestMethod()]
        public void GetExcludedProtectionsTestA()
        {
            GetExcludedProtectionsTest(false);
        }

        /// <summary>
        ///A test for GetEqualsProtectionModesU
        ///</summary>
        [TestMethod()]
        public void GetExcludedProtectionsTestU()
        {
            GetExcludedProtectionsTest(true);
        }

        /// <summary>
        ///A test for GetEqualsProtectionModes
        ///</summary>
        public void GetExcludedProtectionsTest(bool unicode)
        {
            int checkpoint = unicode ? 18 : 19;
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, checkpoint, unicode);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    Options opts = new GetProtectionEntriesCmdOptions(
                        GetProtectionEntriesCmdFlags.AllUsers, null, null, null);

                    IList<ProtectionEntry> target = rep.GetProtectionEntries(null, opts);

                    Assert.AreEqual(target[4].Unmap, false);
                    Assert.AreEqual(target[5].Unmap, false);
                    Assert.AreEqual(target[6].Unmap, false);
                    Assert.AreEqual(target[7].Unmap, false);
                    Assert.AreEqual(target[8].Unmap, true);

                    IList<ProtectionEntry> GetProtectionTable = rep.GetProtectionTable(null);
                    Assert.AreEqual(GetProtectionTable[7].Unmap, false);
                    Assert.AreEqual(GetProtectionTable[8].Unmap, true);
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for TagFiles
        ///</summary>
        [TestMethod()]
        public void TagFilesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 5, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec fs = new FileSpec(new DepotPath("//depot/Modifiers/ReadMe.txt"), null);

                        IList<FileSpec> lfs = new List<FileSpec>();
                        lfs.Add(fs);

                        Options ops = new Options();
                        IList<FileSpec> target = rep.TagFiles(lfs, "admin_label", ops);
                        Assert.IsNotNull(target);
                        bool foundit = false;
                        VersionSpec ver = new Revision(2);

                        foreach (FileSpec f in target)
                        {
                            if (f.DepotPath.Path == "//depot/Modifiers/ReadMe.txt"
                               &&
                               f.Version.ToString() == "#2")

                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFiles
        ///</summary>
        [TestMethod()]
        public void GetFilesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//depot/MyCode2/..."), null);
                        FileSpec filespec1 = new FileSpec(new DepotPath("//depot/Modifiers/..."), null);
                        FileSpec filespec2 = new FileSpec(new DepotPath("//depot/TestData/..."), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        filespecs.Add(filespec1);
                        filespecs.Add(filespec2);
                        Options ops = new Options();

                        IList<File> target = rep.GetFiles(filespecs, ops);

                        bool foundit = false;
                        foreach (File f in target)
                        {
                            if (f.DepotPath.Path == "//depot/TestData/Numbers.txt")
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);


                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetSubmittedIntegrations
        ///</summary>
        [TestMethod()]
        public void GetSubmittedIntegrationsTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//depot/MyCode2/..."), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        Options ops = new Options();

                        IList<FileIntegrationRecord> target = rep.GetSubmittedIntegrations(filespecs, ops);

                        bool foundit = false;
                        foreach (FileIntegrationRecord f in target)
                        {

                            if (f.How == IntegrateAction.BranchFrom)
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                        filespec = null;
                        ops = new Options();
                        ops["-b"] = "MyCode->MyCode2";

                        target = rep.GetSubmittedIntegrations(filespecs, ops);

                        foundit = false;
                        foreach (FileIntegrationRecord f in target)
                        {

                            if (f.FromFile.DepotPath.Path == "//depot/MyCode/ReadMe.txt")
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);


                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileLineMatches
        ///</summary>
        [TestMethod()]
        public void GetFileLineMatchesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//depot/TestData/Letters.txt"), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        string pattern = "kjfrj";
                        Options ops = new Options((GetFileLineMatchesCmdFlags.IncludeLineNumbers), 0, 0, 0);

                        IList<FileLineMatch> target = rep.GetFileLineMatches(filespecs, pattern, ops);

                        bool foundit = false;
                        foreach (FileLineMatch f in target)
                        {

                            if (f.LineNumber == 27)
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileAnnotations
        ///</summary>
        [TestMethod()]
        public void GetFileAnnotationsTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//flow/D1/b/the_other.txt"), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        Options ops = new Options();

                        ops["-ac"] = null;

                        IList<FileAnnotation> target = rep.GetFileAnnotations(filespecs, ops);

                        bool foundit = false;
                        foreach (FileAnnotation f in target)
                        {
                            if (f.Line == "the other\r\n"
                                &&
                                f.File.Version.ToString().Contains("28") &&
                                f.File.Version.ToString().Contains("49"))
                            {
                                foundit = true;
                                break;
                            }
                            if (f.Line == "the other\r\n"
                                &&
                                f.File.Version.ToString().Contains("110") &&
                                f.File.Version.ToString().Contains("131"))
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                        ops = new Options();

                        ops["-acIi"] = null;

                        try
                        {
                            target = rep.GetFileAnnotations(filespecs, ops);
                        }
                        catch (P4Exception e)
                        {
                            Assert.IsNotNull(e);
                            Assert.AreEqual(e.ErrorCode, P4ClientError.MsgServer_UseAnnotate);
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileAnnotations with branches
        ///</summary>
        [TestMethod()]
        public void GetFileAnnotationsBranchesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//flow/D1/b/the_other.txt"), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        Options ops = new Options();

                        ops["-aci"] = null;

                        IList<FileAnnotation> target = rep.GetFileAnnotations(filespecs, ops);
#if DEBUG
                        if (target == null)
                        {
                            P4CommandResult results = rep.Connection.LastResults;
                            foreach (P4ClientError err in results.ErrorList)
                            {
                                Trace.WriteLine(err.ErrorMessage);
                            }
                        }
#endif
                        Assert.IsNotNull(target);
                        bool foundit = false;
                        foreach (FileAnnotation f in target)
                        {
                            if (f.Line == "the other\r\n"
                                &&
                                f.File.Version.ToString().Contains("17") &&
                                f.File.Version.ToString().Contains("49"))
                            {
                                foundit = true;
                                break;
                            }
                            if (f.Line == "the other\r\n"
                                &&
                                f.File.Version.ToString().Contains("99") &&
                                f.File.Version.ToString().Contains("131"))
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileAnnotations with integrations
        ///</summary>
        [TestMethod()]
        public void GetFileAnnotationsIntegrationsTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//flow/D1/b/the_other.txt"), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        Options ops = new Options();

                        ops["-acI"] = null;

                        IList<FileAnnotation> target = rep.GetFileAnnotations(filespecs, ops);

                        bool foundit = false;
                        foreach (FileAnnotation f in target)
                        {
                            if (f.Line == "the other\r\n"
                                &&
                                f.File.Version.ToString().Contains("17") &&
                                f.File.Version.ToString().Contains("49"))
                            {
                                foundit = true;
                                break;
                            }
                            if (f.Line == "the other\r\n"
                                &&
                                f.File.Version.ToString().Contains("99") &&
                                f.File.Version.ToString().Contains("131"))
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileContents
        ///</summary>
        [TestMethod()]
        public void GetFileContentsTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//depot/MyCode/README.txt"), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        Options ops = new Options();

                        IList<string> target = rep.GetFileContents(filespecs, ops);

                        bool foundit = false;
                        foreach (string s in target)
                        {

                            if (s.Contains("Secret"))
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileContentsEx
        ///</summary>
        [TestMethod()]
        public void GetFileContentsExTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 6, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        FileSpec filespec = new FileSpec(new DepotPath("//depot/MyCode/README.txt"), null);
                        IList<FileSpec> filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        Options ops = new Options();

                        IList<object> target = rep.GetFileContentsEx(filespecs, ops);

                        Assert.IsTrue(target[0] is FileSpec);
                        Assert.IsTrue(target[1] is string);
                        string s = target[1] as string;
                        Assert.IsTrue(s.Contains("Secret"));

                        filespec = new FileSpec(new DepotPath("//depot/MyCode/Silly.bmp"), null);
                        filespecs = new List<FileSpec>();
                        filespecs.Add(filespec);
                        ops = new Options();

                        target = rep.GetFileContentsEx(filespecs, ops);

                        Assert.IsTrue(target[0] is FileSpec);
                        Assert.IsTrue(target[1] is byte[]);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetFileDiffs
        ///</summary>
        [TestMethod()]
        public void GetFileDiffsTest()
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";

            Process p4d = Utilities.DeployP4TestServer(TestDir, 2, false);
            Server server = new Server(new ServerAddress(uri));
            try
            {
                Repository rep = new Repository(server);

                using (Connection con = rep.Connection)
                {
                    con.UserName = user;
                    con.Client = new Client();
                    con.Client.Name = ws_client;

                    bool connected = con.Connect(null);
                    Assert.IsTrue(connected);

                    Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                    IList<FileSpec> fsl = new List<FileSpec>();
                    FileSpec fs = new FileSpec(new DepotPath("//depot/TestData/Letters.txt"));
                    fsl.Add(fs);

                    // to set up the diff, we need to revert the checkedout file,
                    // sync it, check it out, and write some text to it.
                    con.Client.RevertFiles(fsl, null);
                    con.Client.SyncFiles(fsl, new SyncFilesCmdOptions(SyncFilesCmdFlags.Force));
                    con.Client.EditFiles(fsl, null);
                    fsl = con.Client.GetClientFileMappings(fsl);
                    System.IO.File.WriteAllText(fsl[0].LocalPath.Path, "just added this");

                    GetFileDiffsCmdOptions opts = new GetFileDiffsCmdOptions(GetFileDiffsCmdFlags.None, 0, 0, 0);
                    IList<FileDiff> target = rep.GetFileDiffs(fsl, opts);

                    FileDiff fd = target[0];
                    Assert.IsNotNull(fd);
                    Assert.AreEqual(fd.LeftFile.DepotPath.Path, "//depot/TestData/Letters.txt");
                    Assert.IsTrue(fd.Diff.Contains("> just added this"));
                }
            }
            finally
            {
                Utilities.RemoveTestServer(p4d, TestDir);
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffs
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//depot/MyCode2/...", "//depot/TestData/...", null);

                        bool foundit = false;
                        foreach (DepotFileDiff d in target)
                        {

                            if (d.LeftFile.DepotPath.Path.Equals("//depot/MyCode2/ReadMe.txt"))
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);

                        target = rep.GetDepotFileDiffs("//depot/MyCode2/ReadMe.txt", "//depot/TestData/Numbers.txt", null);

                        foundit = false;
                        foreach (DepotFileDiff d in target)
                        {

                            if (d.Diff.Contains("Secret!"))
                            {
                                foundit = true;
                                break;
                            }

                        }
                        Assert.IsTrue(foundit);
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsRCS
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsRCSTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.RCS, 0, 100, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);
                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "a7 4\nA change... on Fri Jun 24 16:22:05 PDT 2011\n\nA change... on Fri Jun 24 16:22:07 PDT 2011\n\n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "a7 4\nA change... on Mon Jun 27 15:02:42 PDT 2011\n\nA change... on Mon Jun 27 15:02:42 PDT 2011\n\n");
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsContext
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsContextTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.Context, 100, 0, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);
                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "***************\n*** 1,7 ****\n--- 1,11 ----\n  that\n  that\n  thatA Change on Mon May 16 16:01:35 PDT 2011\n  \n  A Change on Tue May 24 14:04:57 PDT 2011-changes to a-\n  A Change on Tue May 24 14:06:00 PDT 2011-changes to a, again-\n  A Change on Tue May 24 14:28:53 PDT 2011-changes to a alone (again)-\n+ A change... on Fri Jun 24 16:22:05 PDT 2011\n+ \n+ A change... on Fri Jun 24 16:22:07 PDT 2011\n+ \n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "***************\n*** 1,7 ****\n--- 1,11 ----\n  that\n  that\n  thatA Change on Mon May 16 16:01:35 PDT 2011\n  \n  A Change on Tue May 24 14:04:57 PDT 2011-changes to a-\n  A Change on Tue May 24 14:06:00 PDT 2011-changes to a, again-\n  A Change on Tue May 24 14:28:53 PDT 2011-changes to a alone (again)-\n+ A change... on Mon Jun 27 15:02:42 PDT 2011\n+ \n+ A change... on Mon Jun 27 15:02:42 PDT 2011\n+ \n");
                        }

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsSummary
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsSummaryTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.Summary, 0, 100, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);

                        Assert.AreEqual(target[0].Diff, "add 1 chunks 4 lines\ndeleted 0 chunks 0 lines\nchanged 0 chunks 0 / 0 lines\n");
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsUnified
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsUnifiedTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.Unified, 0, 100, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);
                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "@@ -1,7 +1,11 @@\n that\n that\n thatA Change on Mon May 16 16:01:35 PDT 2011\n \n A Change on Tue May 24 14:04:57 PDT 2011-changes to a-\n A Change on Tue May 24 14:06:00 PDT 2011-changes to a, again-\n A Change on Tue May 24 14:28:53 PDT 2011-changes to a alone (again)-\n+A change... on Fri Jun 24 16:22:05 PDT 2011\n+\n+A change... on Fri Jun 24 16:22:07 PDT 2011\n+\n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "@@ -1,7 +1,11 @@\n that\n that\n thatA Change on Mon May 16 16:01:35 PDT 2011\n \n A Change on Tue May 24 14:04:57 PDT 2011-changes to a-\n A Change on Tue May 24 14:06:00 PDT 2011-changes to a, again-\n A Change on Tue May 24 14:28:53 PDT 2011-changes to a alone (again)-\n+A change... on Mon Jun 27 15:02:42 PDT 2011\n+\n+A change... on Mon Jun 27 15:02:42 PDT 2011\n+\n");
                        }

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsIgnoreWSChanges
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsIgnoreWSChangesTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.IgnoreWhitespaceChanges, 0, 100, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);

                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Fri Jun 24 16:22:05 PDT 2011\n> \n> A change... on Fri Jun 24 16:22:07 PDT 2011\n> \n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n");
                        }

                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsIgnoreWS
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsIgnoreWSTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.IgnoreWhitespace, 0, 100, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);

                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Fri Jun 24 16:22:05 PDT 2011\n> \n> A change... on Fri Jun 24 16:22:07 PDT 2011\n> \n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n");
                        }


                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsIgnoreLE
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsIgnoreLETest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.IgnoreLineEndings, 0, 100, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);
                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Fri Jun 24 16:22:05 PDT 2011\n> \n> A change... on Fri Jun 24 16:22:07 PDT 2011\n> \n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n");
                        }
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsLimited
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsLimitedTest()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        Options options = new Options(GetDepotFileDiffsCmdFlags.Limit, 0, 0, null,
                            null, null);
                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", options);

                        // these files are different so the result of the
                        // command should have one diff
                        Assert.AreEqual(target.Count, 1);

                        target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#1", options);

                        // these files are identical so the result of the
                        // command should be null

                        Assert.IsNull(target);

                        // confirm the error message
                        Assert.IsTrue(con.LastResults.ErrorList[0].ErrorMessage.Contains("no differing files."));
                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for GetDepotFileDiffsNoFlags
        ///</summary>
        [TestMethod()]
        public void GetDepotFileDiffsNoFlags()
        {
            bool unicode = false;

            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;
            string ws_client = "admin_space";


            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                Server server = new Server(new ServerAddress(uri));
                try
                {
                    Repository rep = new Repository(server);

                    using (Connection con = rep.Connection)
                    {
                        con.UserName = user;
                        con.Client = new Client();
                        con.Client.Name = ws_client;

                        bool connected = con.Connect(null);
                        Assert.IsTrue(connected);

                        Assert.AreEqual(con.Status, ConnectionStatus.Connected);

                        IList<DepotFileDiff> target = rep.GetDepotFileDiffs("//flow/D1/a/that.txt#1",
                            "//flow/D1/a/that.txt#3", null);

                        if (!(unicode))
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Fri Jun 24 16:22:05 PDT 2011\n> \n> A change... on Fri Jun 24 16:22:07 PDT 2011\n> \n");
                        }
                        else
                        {
                            Assert.AreEqual(target[0].Diff, "7a8,11\n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n> A change... on Mon Jun 27 15:02:42 PDT 2011\n> \n");
                        }


                    }
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }

        /// <summary>
        ///A test for P4APINET-158
        ///</summary>
        [TestMethod()]
        public void P4APINET_158_Test()
        {
            string uri = "localhost:6666";
            string user = "admin";
            string pass = string.Empty;

            bool unicode = false;

            for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
            {
                Process p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
                try
                {
                    Perforce.P4.Server srv = new Perforce.P4.Server(new ServerAddress(uri));
                    Perforce.P4.Repository p4 = new Perforce.P4.Repository(srv);
                    p4.Connection.UserName = user;
                    p4.Connection.Connect(new Perforce.P4.Options());
                    p4.Connection.Login(pass);
                    p4.Connection.Disconnect();
                }
                finally
                {
                    Utilities.RemoveTestServer(p4d, TestDir);
                }
                unicode = !unicode;
            }
        }
    }
}