techy/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
20dcdf3ee1c8ff259f2c47aa09c97d68192b5f3e
UnrealEngine/Engine/Source/ThirdParty/Perforce/P4Api.Net/p4api.net-unit-test/ClientTest.cs
Brandyn / Techy fcc1b09210 init
2026-04-04 15:40:51 -05:00

4578 lines
179 KiB
C#
Raw Blame History

using Perforce.P4;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.IO;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using NLog;
using System.Runtime.Remoting.Messaging;
namespace p4api.net.unit.test
{
/// <summary>
///This is a test class for ClientTest and is intended
///to contain all ClientTest Unit Tests
///</summary>
[TestClass()]
public class ClientTest
{
String TestDir = "c:\\MyTestDir";
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);
}
#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 Client Constructor
///</summary>
[TestMethod()]
public void ClientConstructorTest()
{
Client target = new Client();
Assert.IsNotNull(target);
}
/// <summary>
///A test for FormatDateTime
///</summary>
[TestMethod()]
public void FormatDateTimeTest()
{
DateTime dt = new DateTime(2011, 2, 3, 4, 5, 6); // 2/3/2011 4:05:06
string expected = "2011/02/03 04:05:06";
string actual;
actual = Client.FormatDateTime(dt);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// A test for handling null DateTime object
/// </summary>
[TestMethod()]
public void FormatDateTimeNullTest()
{
DateTime dt = new DateTime();
string expected = "";
string actual;
actual = Client.FormatDateTime(dt);
Assert.AreEqual(expected, actual);
}
/// <summary>
///A test for FromTaggedOutput
///</summary>
[TestMethod()]
public void FromTaggedOutputTest()
{
Client target = new Client(); // TODO: Initialize to an appropriate value
Perforce.P4.TaggedObject workspaceInfo = new Perforce.P4.TaggedObject();
workspaceInfo["Client"] = "clientName";
workspaceInfo["Update"] = "2010/01/02 03:04:05"; // DateTime(2010, 1, 2, 3, 4, 5);
workspaceInfo["Access"] = "2011/02/03 04:05:06"; // DateTime(2011, 2, 3, 4, 5, 6);
workspaceInfo["Owner"] = "JoeOwner";
workspaceInfo["Options"] = "allwrite noclobber compress unlocked modtime normdir";
//new ClientOptionEnum(ClientOption.AllWrite | ClientOption.Compress | ClientOption.ModTime);
workspaceInfo["SubmitOptions"] = "revertunchanged+reopen";
//new ClientSubmitOptions(true, SubmitType.RevertUnchanged);
workspaceInfo["LineEnd"] = "LOCAL"; // LineEnd.Local;
workspaceInfo["Root"] = "C:\\clientname";
workspaceInfo["Host"] = "MissManners";
workspaceInfo["Description"] = "Miss Manners client";
workspaceInfo["AltRoots0"] = "C:\\alt0";
workspaceInfo["AltRoots1"] = "C:\\alt1";
workspaceInfo["Stream"] = "//Rocket/dev1";
workspaceInfo["Type"] = "readonly";
workspaceInfo["ChangeView0"] = "//depot/main/p4/test@1";
workspaceInfo["View0"] = " //depot/main/p4/... //dbarbee_win-dbarbee/main/p4/...";
// new MapEntry(MapType.Include,
// new PathSpec(PathType.DEPOT_PATH, null, "//depot/main/p4/..."),
// new PathSpec(PathType.CLIENT_PATH, null, "//dbarbee_win-dbarbee/main/p4/..."));
workspaceInfo["View1"] = "-//usr/... //dbarbee_win-dbarbee/usr/...";
//new MapEntry(MapType.Exclude,
// new PathSpec(PathType.DEPOT_PATH, null, "//usr/..."),
// new PathSpec(PathType.CLIENT_PATH, null, "//dbarbee_win-dbarbee/usr/..."));
workspaceInfo["View2"] = "+//spec/... //dbarbee_win-dbarbee/spec/...";
//new MapEntry(MapType.Overlay,
// new PathSpec(PathType.DEPOT_PATH, null, "//spec/..."),
// new PathSpec(PathType.CLIENT_PATH, null, "//dbarbee_win-dbarbee/spec/..."));
target.FromClientCmdTaggedOutput(workspaceInfo);
Assert.AreEqual("clientName", target.Name);
Assert.AreEqual(new DateTime(2010, 1, 2, 3, 4, 5), target.Updated);
Assert.AreEqual(new DateTime(2011, 2, 3, 4, 5, 6), target.Accessed);
Assert.AreEqual("JoeOwner", target.OwnerName);
Assert.AreEqual((ClientOption.AllWrite | ClientOption.Compress | ClientOption.ModTime),
target.Options);
Assert.AreEqual(new ClientSubmitOptions(true, SubmitType.RevertUnchanged), target.SubmitOptions);
Assert.AreEqual(LineEnd.Local, target.LineEnd);
Assert.AreEqual("C:\\clientname", target.Root);
Assert.AreEqual("MissManners", target.Host);
Assert.AreEqual("Miss Manners client", target.Description);
Assert.AreEqual("C:\\alt0", target.AltRoots[0]);
Assert.AreEqual("C:\\alt1", target.AltRoots[1]);
Assert.AreEqual(ClientType.@readonly, target.ClientType);
Assert.AreEqual("//depot/main/p4/test@1", target.ChangeView[0]);
Assert.AreEqual("//Rocket/dev1", target.Stream);
Assert.AreEqual(new MapEntry(MapType.Include,
new DepotPath("//depot/main/p4/..."),
new ClientPath("//dbarbee_win-dbarbee/main/p4/...")),
target.ViewMap[0]);
Assert.AreEqual(new MapEntry(MapType.Exclude,
new DepotPath("//usr/..."),
new ClientPath("//dbarbee_win-dbarbee/usr/...")),
target.ViewMap[1]);
Assert.AreEqual(new MapEntry(MapType.Overlay,
new DepotPath("//spec/..."),
new ClientPath("//dbarbee_win-dbarbee/spec/...")),
target.ViewMap[2]);
}
/// <summary>
///A test for Parse
///</summary>
[TestMethod()]
public void ParseTest()
{
Client target = new Client(); // TODO: Initialize to an appropriate value
string spec =
"Client:\tclientName\r\n\r\nUpdate:\t2010/01/02 03:04:05\r\n\r\nAccess:\t2011/02/03 04:05:06\r\n\r\nOwner:\tJoeOwner\r\n\r\nHost:\tMissManners\r\n\r\nDescription:\r\n\tMiss Manners client\r\n\r\nRoot:\tC:\\clientname\r\n\r\nAltRoots:\r\n\tC:\\alt0\r\n\tC:\\alt1\r\n\r\nChangeView:\r\n\t//depot/main/p4/changeview1@1\r\n\t//depot/main/p4/changeview2@1\r\n\r\nOptions:\tallwrite noclobber compress unlocked modtime normdir\r\n\r\nSubmitOptions:\trevertunchanged+reopen\r\n\r\nLineEnd:\tLocal\r\n\r\nView:\r\n\t//depot/main/p4/... //dbarbee_win-dbarbee/main/p4/...\r\n\t-//usr/... //dbarbee_win-dbarbee/usr/...\r\n\t+//spec/... //dbarbee_win-dbarbee/spec/...\r\n";
bool expected = true;
bool actual;
actual = target.Parse(spec);
Assert.AreEqual(expected, actual);
Assert.AreEqual("clientName", target.Name);
Assert.AreEqual(new DateTime(2010, 1, 2, 3, 4, 5), target.Updated);
Assert.AreEqual(new DateTime(2011, 2, 3, 4, 5, 6), target.Accessed);
Assert.AreEqual("JoeOwner", target.OwnerName);
Assert.AreEqual((ClientOption.AllWrite | ClientOption.Compress | ClientOption.ModTime),
target.Options);
Assert.AreEqual(new ClientSubmitOptions(true, SubmitType.RevertUnchanged), target.SubmitOptions);
Assert.AreEqual(LineEnd.Local, target.LineEnd);
Assert.AreEqual("C:\\clientname", target.Root);
Assert.AreEqual("MissManners", target.Host);
Assert.AreEqual("Miss Manners client", target.Description);
Assert.AreEqual("C:\\alt0", target.AltRoots[0]);
Assert.AreEqual("C:\\alt1", target.AltRoots[1]);
Assert.AreEqual("//depot/main/p4/changeview1@1", target.ChangeView[0]);
Assert.AreEqual("//depot/main/p4/changeview2@1", target.ChangeView[1]);
Assert.AreEqual(new MapEntry(MapType.Include,
new DepotPath("//depot/main/p4/..."),
new ClientPath("//dbarbee_win-dbarbee/main/p4/...")),
target.ViewMap[0]);
Assert.AreEqual(new MapEntry(MapType.Exclude,
new DepotPath("//usr/..."),
new ClientPath("//dbarbee_win-dbarbee/usr/...")),
target.ViewMap[1]);
Assert.AreEqual(new MapEntry(MapType.Overlay,
new DepotPath("//spec/..."),
new ClientPath("//dbarbee_win-dbarbee/spec/...")),
target.ViewMap[2]);
}
/// <summary>
///A test for ToStringjob084053
///</summary>
[TestMethod()]
public void ToStringTestjob084053()
{
Client target = new Client();
target.Name = "clientName";
target.Updated = new DateTime(2010, 1, 2, 3, 4, 5);
target.Accessed = new DateTime(2011, 2, 3, 4, 5, 6);
target.OwnerName = "JoeOwner";
// Don't set target.Options, target.SubmitOptions, and target.LineEnd
// to confirm default values are set on Client creation.
target.Root = "C:\\clientname";
target.Host = "MissManners";
target.Description = "Miss Manners client";
target.AltRoots = new List<string>();
target.AltRoots.Add("C:\\alt0");
target.AltRoots.Add("C:\\alt1");
target.ServerID = "perforce:1666";
target.Stream = "//Stream/main";
target.StreamAtChange = "111";
target.ViewMap = new ViewMap(new string[]
{
" //depot/main/p4/... //dbarbee_win-dbarbee/main/p4/...",
"-//usr/... //dbarbee_win-dbarbee/usr/...",
"+//spec/... //dbarbee_win-dbarbee/spec/..."
});
string expected =
"Client:\tclientName\n\nUpdate:\t2010/01/02 03:04:05\n\nAccess:\t2011/02/03 04:05:06\n\nOwner:\tJoeOwner\n\nHost:\tMissManners\n\nDescription:\n\tMiss Manners client\n\nRoot:\tC:\\clientname\n\nAltRoots:\n\tC:\\alt0\n\tC:\\alt1\n\nOptions:\tnoallwrite noclobber nocompress unlocked nomodtime normdir\n\nSubmitOptions:\tsubmitunchanged\n\nLineEnd:\tLocal\n\nType:\twriteable\n\nStream:\t//Stream/main\n\nStreamAtChange:\t111\n\nServerID:\tperforce:1666\n\nView:\n\t//depot/main/p4/... //dbarbee_win-dbarbee/main/p4/...\n\t-//usr/... //dbarbee_win-dbarbee/usr/...\n\t+//spec/... //dbarbee_win-dbarbee/spec/...\n";
string actual;
actual = target.ToString();
Assert.AreEqual(expected, actual);
}
/// <summary>
///A test for ToString
///</summary>
[TestMethod()]
public void ToStringTest()
{
Client target = new Client();
target.Name = "clientName";
target.Updated = new DateTime(2010, 1, 2, 3, 4, 5);
target.Accessed = new DateTime(2011, 2, 3, 4, 5, 6);
target.OwnerName = "JoeOwner";
target.Options = (ClientOption.AllWrite | ClientOption.Compress | ClientOption.ModTime);
target.SubmitOptions = new ClientSubmitOptions(true, SubmitType.RevertUnchanged);
target.LineEnd = LineEnd.Local;
target.Root = "C:\\clientname";
target.Host = "MissManners";
target.Description = "Miss Manners client";
target.AltRoots = new List<string>();
target.AltRoots.Add("C:\\alt0");
target.AltRoots.Add("C:\\alt1");
target.ServerID = "perforce:1666";
target.Stream = "//Stream/main";
target.StreamAtChange = "111";
target.ChangeView = new List<string>();
target.ChangeView.Add("//dbarbee_win-dbarbee/main/p4/test@2");
target.ViewMap = new ViewMap(new string[]
{
" //depot/main/p4/... //dbarbee_win-dbarbee/main/p4/...",
"-//usr/... //dbarbee_win-dbarbee/usr/...",
"+//spec/... //dbarbee_win-dbarbee/spec/..."
});
string expected =
"Client:\tclientName\n\nUpdate:\t2010/01/02 03:04:05\n\nAccess:\t2011/02/03 04:05:06\n\nOwner:\tJoeOwner\n\nHost:\tMissManners\n\nDescription:\n\tMiss Manners client\n\nRoot:\tC:\\clientname\n\nAltRoots:\n\tC:\\alt0\n\tC:\\alt1\n\nOptions:\tallwrite noclobber compress unlocked modtime normdir\n\nSubmitOptions:\trevertunchanged+reopen\n\nLineEnd:\tLocal\n\nType:\twriteable\n\nStream:\t//Stream/main\n\nStreamAtChange:\t111\n\nServerID:\tperforce:1666\n\nChangeView:\t//dbarbee_win-dbarbee/main/p4/test@2\n\nView:\n\t//depot/main/p4/... //dbarbee_win-dbarbee/main/p4/...\n\t-//usr/... //dbarbee_win-dbarbee/usr/...\n\t+//spec/... //dbarbee_win-dbarbee/spec/...\n";
string actual;
actual = target.ToString();
Assert.AreEqual(expected, actual);
}
/// <summary>
///A test for AltRootsStr
///</summary>
[TestMethod()]
public void AltRootsStrTest()
{
Client target = new Client();
List<string> expected = new List<string>();
string root = @"C:\depot";
expected.Add(root);
target.AltRoots = expected;
IList<string> actual;
actual = target.AltRoots;
Assert.IsTrue(actual.Contains(@"C:\depot"));
}
/// <summary>
///A test for LineEnd
///</summary>
[TestMethod()]
public void LineEndTest()
{
Client target = new Client();
LineEnd expected = LineEnd.Mac;
LineEnd actual;
target.LineEnd = expected;
actual = target.LineEnd;
Assert.AreEqual(expected, actual);
}
/// <summary>
///A test for Options
///</summary>
[TestMethod()]
public void OptionsTest()
{
Client target = new Client();
ClientOption expected = ClientOption.Clobber;
ClientOption actual;
target.Options = expected;
actual = target.Options;
Assert.AreEqual(expected, actual);
}
/// <summary>
///A test for initialize
///</summary>
[TestMethod()]
public void initializeTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
string dir = Directory.GetCurrentDirectory();
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
if (unicode)
{
con.CharacterSetName = "utf8";
Assert.AreEqual("utf8", con.CharacterSetName);
}
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for addFiles
///</summary>
[TestMethod()]
public void addFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
string dir = Directory.GetCurrentDirectory();
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
if (unicode)
{
con.CharacterSetName = "utf8";
Assert.AreEqual("utf8", con.CharacterSetName);
}
else
{
con.CharacterSetName = "none";
Assert.AreEqual("none", con.CharacterSetName);
}
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
var codePath = Path.Combine(clientRoot, "admin_space", "MyCode");
Directory.CreateDirectory(codePath);
System.IO.File.Copy(Path.Combine(codePath, "ReadMe.txt"),
Path.Combine(codePath, "NewFile2.txt"));
FileSpec toFile = new FileSpec(new LocalPath(Path.Combine(codePath, "NewFile2.txt")), null);
Options options = new Options(AddFilesCmdFlags.None, -1, null);
IList<FileSpec> newfiles = con.Client.AddFiles(options, toFile);
Assert.AreEqual(1, newfiles.Count);
foreach (var fileSpec in newfiles)
{
Assert.IsNotNull(fileSpec.DepotPath.Path);
Assert.IsNotNull(fileSpec.ClientPath.Path);
Assert.IsNotNull(fileSpec.LocalPath.Path);
}
con.Client.RevertFiles(null, toFile);
options = new Options(AddFilesCmdFlags.None, 0, null);
newfiles = con.Client.AddFiles(options, toFile);
Assert.AreEqual(1, newfiles.Count);
foreach (var fileSpec in newfiles)
{
Assert.IsNotNull(fileSpec.DepotPath.Path);
Assert.IsNotNull(fileSpec.ClientPath.Path);
Assert.IsNotNull(fileSpec.LocalPath.Path);
}
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for addFilesjob085728U
///</summary>
[TestMethod()]
public void addFilesTestjob085728U()
{
addFilesTestjob085728(true);
}
/// <summary>
///A test for addFilesjob085728A
///</summary>
[TestMethod()]
public void addFilesTestjob085728A()
{
addFilesTestjob085728(false);
}
/// <summary>
///A test for addFilesjob085728
///</summary>
public void addFilesTestjob085728(bool unicode)
{
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
string dir = Directory.GetCurrentDirectory();
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
if (unicode)
{
con.CharacterSetName = "utf8";
Assert.AreEqual("utf8", con.CharacterSetName);
}
else
{
con.CharacterSetName = "none";
Assert.AreEqual("none", con.CharacterSetName);
}
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
var codePath = Path.Combine(clientRoot, "admin_space", "MyCode");
Directory.CreateDirectory(codePath);
System.IO.File.Copy(Path.Combine(codePath, "ReadMe.txt"),
Path.Combine(codePath, "NewFile2.txt"));
FileSpec toFile = new FileSpec(new LocalPath(Path.Combine(codePath, "NewFile2.txt")), null);
Options options = new Options(AddFilesCmdFlags.None, -1, null);
IList<FileSpec> newfiles = con.Client.AddFiles(options, toFile);
Assert.AreEqual(1, newfiles.Count);
// Check to confirm that the rev is null for a filespec
// of a file marked for add
Assert.IsTrue(newfiles[0].Version == null);
foreach (var fileSpec in newfiles)
{
Assert.IsNotNull(fileSpec.DepotPath.Path);
Assert.IsNotNull(fileSpec.ClientPath.Path);
Assert.IsNotNull(fileSpec.LocalPath.Path);
}
IList<Perforce.P4.File> files = rep.GetOpenedFiles(newfiles, options);
// Check to confirm that the rev is null for a file
// of a file marked for add
Assert.IsTrue(files[0].Version == null);
// get filemetadata for the file marked for add. Previously
// this would come back null when attempting to fstat
// //depot/filemarkedforadd#1 as it would return
// "no such file(s)"
IList<FileMetaData> fmd = rep.GetFileMetaData(newfiles, null);
Assert.IsNotNull(fmd);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
/// Test fstat calls - for performance - both existing and non-existent files
/// </summary>
[TestMethod()]
public void fstatTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
var codePath = Path.Combine(clientRoot, "admin_space", "MyCode");
var newFile = Path.Combine(codePath, "NewFile2.txt");
Directory.CreateDirectory(codePath);
System.IO.File.Copy(Path.Combine(codePath, "ReadMe.txt"),
newFile);
FileSpec fs = FileSpec.DepotSpec("//depot/MyCode/ReadMe.txt");
logger.Debug("Fstating {0}", fs.DepotPath.Path);
Options ops = new Options();
IList<FileMetaData> actual = rep.GetFileMetaData(ops, fs);
FileAction expected = FileAction.Add;
Assert.AreEqual(expected, actual[0].HeadAction);
// Now try for a non-existent file
fs = FileSpec.LocalSpec(newFile);
logger.Debug("Fstating {0}", fs.LocalPath.Path);
actual = rep.GetFileMetaData(ops, fs);
Assert.AreEqual(actual, null);
Assert.AreEqual(1, rep.Connection.LastResults.ErrorList.Count);
Assert.AreEqual(ErrorSeverity.E_WARN, rep.Connection.LastResults.ErrorList[0].SeverityLevel);
Assert.IsTrue(rep.Connection.LastResults.ErrorList[0].ToString().Contains("no such file(s)"));
logger.Debug("Finished fstat");
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for DeleteFiles
///</summary>
[TestMethod()]
public void DeleteFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec toFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode\\ReadMe.txt")),
null);
Options options = new Options(DeleteFilesCmdFlags.None, -1);
IList<FileSpec> oldfiles = con.Client.DeleteFiles(options, toFile);
Assert.AreEqual(1, oldfiles.Count);
con.Client.RevertFiles(null, toFile);
options = new Options(DeleteFilesCmdFlags.None, 0);
oldfiles = con.Client.DeleteFiles(options, toFile);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for DeleteFiles with Preview Only option
///</summary>
[TestMethod()]
public void DeleteFilesPreviewOnlyTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
String filePath = Path.Combine(adminSpace, "MyCode", "ReadMe.txt");
FileSpec toFile = new FileSpec(new LocalPath(filePath), null);
Options options = new Options(DeleteFilesCmdFlags.PreviewOnly, -1);
IList<FileSpec> oldfiles = con.Client.DeleteFiles(options, toFile);
Assert.IsTrue(System.IO.File.Exists(filePath), filePath + " does not exist.");
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for DeleteFiles with Server Only option
///</summary>
[TestMethod()]
public void DeleteFilesServerOnlyTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
String filePath = Path.Combine(adminSpace, "MyCode", "ReadMe.txt");
FileSpec toFile = new FileSpec(new LocalPath(filePath), null);
Options options = new Options(DeleteFilesCmdFlags.ServerOnly, -1);
IList<FileSpec> oldfiles = con.Client.DeleteFiles(options, toFile);
FileSpec fs = FileSpec.DepotSpec("//depot/MyCode/ReadMe.txt");
Options ops = new Options();
IList<FileMetaData> actual = rep.GetFileMetaData(ops, fs);
FileAction expected = FileAction.Delete;
Assert.AreEqual(expected, actual[0].Action);
Assert.IsTrue(System.IO.File.Exists(filePath), filePath + " does not exist.");
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for DeleteFiles with Unsynced option
///</summary>
[TestMethod()]
public void DeleteFilesUnsyncedTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
String filePath = Path.Combine(adminSpace, "MyCode", "ReadMe.txt");
String depotPath = "//depot/MyCode/ReadMe.txt";
FileSpec toFile = new FileSpec(new DepotPath(depotPath));
FileSpec toFile0 = new FileSpec(new DepotPath(depotPath), null, null, VersionSpec.None);
con.Client.SyncFiles(null, toFile0);
Options options = new Options(DeleteFilesCmdFlags.DeleteUnsynced, -1);
IList<FileSpec> oldfiles = con.Client.DeleteFiles(options, toFile);
FileSpec fs = FileSpec.DepotSpec(depotPath);
IList<FileMetaData> actual = rep.GetFileMetaData(null, fs);
FileAction expected = FileAction.Delete;
Assert.AreEqual(expected, actual[0].Action);
Assert.IsFalse(System.IO.File.Exists(filePath));
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for EditFiles
///</summary>
[TestMethod()]
public void EditFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec toFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode", "ReadMe.txt")),
null);
Options options = new Options(EditFilesCmdFlags.None, -1, null);
IList<FileSpec> oldfiles = con.Client.EditFiles(options, toFile);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for GetSyncedFiles
///</summary>
[TestMethod()]
public void GetSyncedFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec toFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode\\ReadMe.txt")),
null);
Options options = null;
IList<FileSpec> oldfiles = con.Client.GetSyncedFiles(options, toFile);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for IntegrateFiles for the
///"p4 integrate [options] fromFile[revRange] toFile"
///version of integrate
///</summary>
[TestMethod()]
public void IntegrateFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode\\ReadMe.txt")),
null);
FileSpec toFile =
new FileSpec(new LocalPath(Path.Combine(adminSpace, "branchAlpha\\ReadMe.txt")), null);
Options options = new Options(IntegrateFilesCmdFlags.None,
-1,
10,
null,
null,
null);
IList<FileSpec> oldfiles = con.Client.IntegrateFiles(fromFile, options, toFile);
Assert.AreEqual(1, oldfiles.Count);
con.Client.RevertFiles(null, toFile);
options = new Options(IntegrateFilesCmdFlags.None,
0,
10,
null,
null,
null);
oldfiles = con.Client.IntegrateFiles(fromFile, options, toFile);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for IntegrateFiles for the
///"p4 integrate [options] -b branch [-r] [toFile[revRange] ...]"
///version of integrate
///</summary>
[TestMethod()]
public void IntegrateFilesTest1()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 10, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
string branch = "MyCode->MyCode2";
List<FileSpec> toFiles = new List<FileSpec>();
FileSpec toFile = new FileSpec(new DepotPath("//depot/MyCode2/Silly.bmp"), null);
toFiles.Add(toFile);
Options options = new Options(IntegrateFilesCmdFlags.Force,
-1,
10,
branch,
null,
null);
IList<FileSpec> oldfiles = con.Client.IntegrateFiles(toFiles, options);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for LabelSync
///</summary>
[TestMethod()]
public void LabelSyncTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 4, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
IList<FileSpec> oldfiles = con.Client.LabelSync(null, "admin_label", (FileSpec) null);
Assert.AreEqual(null, oldfiles);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for LockFiles
///</summary>
[TestMethod()]
public void LockFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 5, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
IList<FileSpec> oldfiles = con.Client.LockFiles(null);
Assert.AreNotEqual(null, oldfiles);
con.Client.UnlockFiles(null);
Options lockOpts = new LockCmdOptions(-1);
oldfiles = con.Client.LockFiles(lockOpts, (FileSpec) null);
con.Client.UnlockFiles(null);
lockOpts = new LockCmdOptions(0);
oldfiles = con.Client.LockFiles(lockOpts, (FileSpec) null, (FileSpec) null, (FileSpec) null);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for MoveFiles
///</summary>
[TestMethod()]
public void MoveFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode\\ReadMe.txt")),
null);
IList<FileSpec> oldfiles = con.Client.EditFiles(null, fromFile);
Assert.AreEqual(1, oldfiles.Count);
FileSpec toFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode\\ReadMe42.txt")),
null);
Options options = new Options(MoveFileCmdFlags.None, -1, null);
oldfiles = con.Client.MoveFiles(fromFile, toFile, options);
Assert.AreEqual(1, oldfiles.Count);
con.Client.RevertFiles(null, toFile);
oldfiles = con.Client.EditFiles(null, fromFile);
Assert.AreEqual(1, oldfiles.Count);
options = new Options(MoveFileCmdFlags.None, 0, null);
oldfiles = con.Client.MoveFiles(fromFile, toFile, options);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ReopenFiles
///</summary>
[TestMethod()]
public void ReopenFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, unicode, TestContext.TestName);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode\\ReadMe.txt")),
null);
IList<FileSpec> oldfiles = con.Client.EditFiles(null, fromFile);
Assert.AreEqual(1, oldfiles.Count);
FileType ft = new FileType(BaseFileType.Unicode, FileTypeModifier.ExclusiveOpen);
Options ops = new Options(-1, ft);
oldfiles = con.Client.ReopenFiles(ops, fromFile);
Assert.AreEqual(1, oldfiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ResolveFiles
///</summary>
[TestMethod()]
public void ResolveFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Options rFlags = new Options(
ResolveFilesCmdFlags.PreviewOnly, -1);
IList<FileResolveRecord> records = con.Client.ResolveFiles(rFlags, fromFile);
Assert.IsNotNull(records);
rFlags = new Options(ResolveFilesCmdFlags.AutomaticForceMergeMode, -1);
records = con.Client.ResolveFiles(rFlags, fromFile);
Assert.IsNotNull(records);
con.Client.RevertFiles(null, fromFile);
fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
rFlags = new Options(
ResolveFilesCmdFlags.PreviewOnly, 0);
records = con.Client.ResolveFiles(rFlags, fromFile);
// they no longer need resolve at this point
// only testing the rFlag with changelist 0
Assert.IsNull(records);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ResolveFiles
///</summary>
[TestMethod()]
public void ResolveFilesTest0()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec depotFiles = FileSpec.DepotSpec("//depot/MyCode2/...");
IList<FileSpec> files = new List<FileSpec>();
files.Add(new FileSpec(new DepotPath("//depot/MyCode2/DeleteResolve2.txt"), null, null, null));
files.Add(new FileSpec(new DepotPath("//depot/MyCode2/ReadMe.txt"), null, null, null));
rep.Connection.Client.ReopenFiles(files, new Options(6, null));
Options autoResolveOptions = new ResolveCmdOptions(ResolveFilesCmdFlags.AutomaticMergeMode, 6);
rep.Connection.Client.ResolveFiles(autoResolveOptions, depotFiles);
P4CommandResult results = con.LastResults;
Assert.IsTrue(results.Success);
IList<FileMetaData> fstat = rep.GetFileMetaData(files, null);
Assert.IsTrue(fstat[0].Resolved);
Assert.IsTrue(fstat[1].Resolved);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ResolveFiles
///</summary>
// [TestMethod()] // Disable this test for now, it seems to not work reliably and brings up the editor requiring manual intervention
public void ResolveFilesTest1()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Dictionary<String, String> responses = new Dictionary<string, string>();
responses["Accept(a) Edit(e) Diff(d) Merge (m) Skip(s) Help(?) am: "] = "am";
responses["Accept(a) Edit(e) Diff(d) Merge (m) Skip(s) Help(?) e:"] = "a";
responses["There are still change markers: confirm accept (y/n)"] = "y";
Options rFlags = new Options(ResolveFilesCmdFlags.IgnoreWhitespace, -1);
#pragma warning disable 618
IList<FileResolveRecord> records = con.Client.ResolveFiles(null, null, responses, rFlags,
fromFile);
#pragma warning restore 618
Assert.IsNotNull(records);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
private String HandlePrompt(uint cmdId, String msg, bool displayText)
{
if (msg == "Accept(a) Edit(e) Diff(d) Merge (m) Skip(s) Help(?) am: ")
return "am";
return "s";
}
/// <summary>
///A test for ResolveFiles
///</summary>
[TestMethod()]
public void ResolveFilesTest2()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Perforce.P4.P4Server.PromptHandlerDelegate promptHandler =
new Perforce.P4.P4Server.PromptHandlerDelegate(HandlePrompt);
Options rFlags = new Options(ResolveFilesCmdFlags.IgnoreWhitespace, -1);
#pragma warning disable 618
IList<FileResolveRecord> records = con.Client.ResolveFiles(null, promptHandler, null, rFlags,
fromFile);
#pragma warning restore 618
Assert.IsNotNull(records);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
private Connection resolveCon = null;
private P4ClientMerge.MergeStatus HandleResolve(uint cmdId, P4ClientMerge merger)
{
if (resolveCon != null)
{
TaggedObjectList taggedOut = resolveCon.getP4Server().GetTaggedOutput(cmdId);
P4ClientInfoMessageList infoOut = resolveCon.getP4Server().GetInfoResults(cmdId);
}
if (merger.AutoResolve(P4ClientMerge.MergeForce.CMF_AUTO) == P4ClientMerge.MergeStatus.CMS_MERGED)
{
return P4ClientMerge.MergeStatus.CMS_MERGED;
}
return P4ClientMerge.MergeStatus.CMS_SKIP;
}
/// <summary>
///A test for ResolveFiles
///</summary>
[TestMethod()]
public void ResolveFilesTest3()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Perforce.P4.P4Server.ResolveHandlerDelegate resolveHandler =
new Perforce.P4.P4Server.ResolveHandlerDelegate(HandleResolve);
Options rFlags = new Options(ResolveFilesCmdFlags.IgnoreWhitespace, -1);
resolveCon = con;
#pragma warning disable 618
IList<FileResolveRecord> records = con.Client.ResolveFiles(resolveHandler, null, null, rFlags,
fromFile);
#pragma warning restore 618
resolveCon = null;
Assert.IsNotNull(records);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ResolveFiles
///</summary>
[TestMethod()]
public void ResolveFilesTest4()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile1 = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile1);
}
catch
{
} // will fail because we need to resolve
Options rFlags = new Options(ResolveFilesCmdFlags.AutomaticMergeMode, -1);
resolveCon = con;
IList<FileResolveRecord> records = con.Client.ResolveFiles(null, rFlags, fromFile1);
//, fromFile2, fromFile3);
resolveCon = null;
Assert.IsNotNull(records);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
private bool itWorked = true;
private P4ClientMerge.MergeStatus ResolveHandler6(FileResolveRecord resolveRecord,
Client.AutoResolveDelegate AutoResolve, string sourcePath, string targetPath, string basePath,
string resultsPath)
{
itWorked = true;
if (sourcePath != null)
itWorked &= System.IO.File.Exists(sourcePath);
if (targetPath != null)
itWorked &= System.IO.File.Exists(targetPath);
if (basePath != null)
itWorked &= System.IO.File.Exists(basePath);
if (resultsPath != null)
itWorked &= System.IO.File.Exists(resultsPath);
return P4ClientMerge.MergeStatus.CMS_SKIP;
}
/// <summary>
///A test for ResolveFiles
///</summary>
[TestMethod()]
public void ResolveFilesTest6()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 12, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
//
// NEEDS WORK!
//
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile1 =
new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode2\\BranchResolve.txt")), null);
FileSpec fromFile2 =
new FileSpec(new LocalPath(Path.Combine(adminSpace, "MyCode2\\DeleteResolve2.txt")), null);
FileSpec fromFile3 = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options rFlags = new Options(ResolveFilesCmdFlags.DisplayBaseFile, -1);
resolveCon = con;
Client.ResolveFileDelegate resolver = new Client.ResolveFileDelegate(ResolveHandler6);
IList<FileResolveRecord> records = con.Client.ResolveFiles(resolver, rFlags, fromFile1,
fromFile2, fromFile3);
resolveCon = null;
Assert.IsNotNull(records);
Assert.IsTrue(itWorked);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for SubmitFiles
///</summary>
[TestMethod()]
public void SubmitFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 3, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = null;
// new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt"), null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Submit the default changelist",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Assert.IsNotNull(sr);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for SubmitFiles
///</summary>
[TestMethod()]
public void SubmitFilesTest0()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 3, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fileToSubmit = new FileSpec(new DepotPath("//depot/TestData/Letters.txt"),
null, null, null);
SubmitCmdOptions submitOptions = new SubmitCmdOptions(
SubmitFilesCmdFlags.None, 0, null, "submitting default changelist", null);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(submitOptions, fileToSubmit);
}
catch
{
} // will fail because we need to resolve
Assert.IsNotNull(sr);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for SubmitFiles
///</summary>
[TestMethod()]
public void SubmitFilesTest1()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 3, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist();
change.Description = "On the fly built change list";
FileMetaData file = new FileMetaData();
file.DepotPath = new DepotPath("//depot/TestData/Letters.txt");
change.Files.Add(file);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
change,
null,
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, null);
}
catch
{
} // will fail because we need to resolve
Assert.IsNotNull(sr);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for SubmitFiles
///</summary>
[TestMethod()]
public void SubmitFilesTest2()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 3, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
5,
null,
null,
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, null);
}
catch
{
} // will fail because we need to resolve
Assert.IsNotNull(sr);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for SubmitFiles
///</summary>
[TestMethod()]
public void SubmitShelvedFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Options sFlags = new Options(
ShelveFilesCmdFlags.None,
null,
5
);
IList<FileSpec> rFiles = con.Client.ShelveFiles(sFlags);
rFiles[0].Version = null;
sFlags = new Options(
RevertFilesCmdFlags.None, 5);
rFiles = con.Client.RevertFiles(rFiles, sFlags);
sFlags = new Options(
SubmitFilesCmdFlags.SubmitShelved,
5,
null,
null,
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, null);
}
catch
{
} // will fail because we need to resolve
Assert.IsNotNull(sr);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
public void SubmitFilesTest3()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 3, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Test submit",
null
);
SubmitResults sr = null;
try
{
FileSpec fs = FileSpec.LocalSpec(Path.Combine(adminSpace, "TestData\\Letters.txt"));
sr = con.Client.SubmitFiles(sFlags, fs);
}
catch
{
} // will fail because we need to resolve
Assert.IsNotNull(sr);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for Parallel SubmitFiles
///</summary>
[TestMethod()]
public void ParallelSubmitFilesTestA()
{
ParallelSubmitFilesTest(false);
}
[TestMethod()]
public void ParallelSubmitFilesTestU()
{
ParallelSubmitFilesTest(true);
}
public void ParallelSubmitFilesTest(bool unicode)
{
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
int fileCount = 500; // remember that this is an unlicensed server
Process p4d = null;
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
string clientDir = Path.Combine(TestDir, ws_client);
string syncFilesDir = Path.Combine(clientDir, "parallel");
FileSpec parallelFileSpec = FileSpec.ClientSpec(syncFilesDir + "\\...");
var parallelFileSpecArray = new FileSpec[] { parallelFileSpec };
FileSpec parallelFileSpecZero = FileSpec.ClientSpec(syncFilesDir + "\\...", VersionSpec.None);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
// Set up a bunch of files in the workspace
PrepSyncFiles(syncFilesDir);
CreateSyncFiles(syncFilesDir, fileCount);
Changelist change = new Changelist();
change.Description = "On the fly built change list";
Changelist newChange = rep.CreateChangelist(change, null);
// Add them to the server
Options addFlags = new Options(AddFilesCmdFlags.None, newChange.Id, null);
IList<FileSpec> addFiles = con.Client.AddFiles(addFlags, parallelFileSpecArray);
Options submitFlags = new SubmitCmdOptions(
SubmitFilesCmdFlags.DisableParallel, newChange.Id, null, null,
new ClientSubmitOptions(false, SubmitType.SubmitUnchanged));
// submit the files
SubmitResults sr = con.Client.SubmitFiles(submitFlags, null);
// confirm that cmd flags were passed to disable parallel
Assert.IsNotNull(sr);
string[] lastResults = con.LastResults.CmdArgs;
Assert.IsTrue((Array.IndexOf(lastResults, "--parallel")) > -1);
Assert.IsTrue((Array.IndexOf(lastResults, "0")) > -1);
change = new Changelist();
change.Description = "On the fly built change list";
newChange = rep.CreateChangelist(change, null);
// move files to new change
con.Client.EditFiles(new EditCmdOptions(new EditFilesCmdFlags(),
newChange.Id, null), parallelFileSpecArray);
// now submit them with parallel
submitFlags = new SubmitCmdOptions(
SubmitFilesCmdFlags.None, newChange.Id, null, null,
new ClientSubmitOptions(true, SubmitType.SubmitUnchanged),
0, 4, 10, 0, 100);
sr = con.Client.SubmitFiles(submitFlags, null);
// confirm that no cmd flags were passed to disable parallel
Assert.IsNotNull(sr);
lastResults = con.LastResults.CmdArgs;
Assert.IsFalse((Array.IndexOf(lastResults, "--parallel")) > -1);
Assert.IsFalse((Array.IndexOf(lastResults, "0")) > -1);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
///A test for GetResolveFiles
///</summary>
[TestMethod()]
public void GetResolvedFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Options rFlags = new Options(
ResolveFilesCmdFlags.AutomaticForceMergeMode | ResolveFilesCmdFlags.PreviewOnly, -1);
IList<FileResolveRecord> records = con.Client.ResolveFiles(rFlags, fromFile);
Assert.IsNotNull(records);
rFlags = new Options(
ResolveFilesCmdFlags.AutomaticForceMergeMode, -1);
records = con.Client.ResolveFiles(rFlags, fromFile);
Assert.IsNotNull(records);
Options opts = new Options(GetResolvedFilesCmdFlags.IncludeBaseRevision);
IList<FileResolveRecord> rFiles = con.Client.GetResolvedFiles(opts, null);
Assert.IsNotNull(rFiles);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for GetResolveFilesjob085495A
///</summary>
[TestMethod()]
public void GetResolvedFilesTestjob085495A()
{
GetResolvedFilesTestjob085495(false);
}
/// <summary>
///A test for GetResolveFiles
///</summary>
public void GetResolvedFilesTestjob085495(bool unicode)
{
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
SubmitFilesCmdFlags.None,
-1,
null,
"Check It In!",
null
);
SubmitResults sr = null;
try
{
sr = con.Client.SubmitFiles(sFlags, fromFile);
}
catch
{
} // will fail because we need to resolve
Options rFlags = new Options(
ResolveFilesCmdFlags.AutomaticForceMergeMode | ResolveFilesCmdFlags.PreviewOnly, -1);
IList<FileResolveRecord> records = con.Client.ResolveFiles(rFlags, fromFile);
Assert.IsNotNull(records);
rFlags = new Options(
ResolveFilesCmdFlags.AutomaticForceMergeMode, -1);
records = con.Client.ResolveFiles(rFlags, fromFile);
Assert.IsNotNull(records);
Options opts = new Options(GetResolvedFilesCmdFlags.IncludeBaseRevision);
IList<FileResolveRecord> rFiles = con.Client.GetResolvedFiles(opts, null);
Assert.IsNotNull(rFiles);
Assert.AreEqual(rFiles.Count, 2);
Assert.AreEqual(rFiles[0].FromFileSpec.Version, new VersionRange(1, 2));
Assert.AreEqual(rFiles[0].FromFileSpec.Version, new VersionRange(1, 2));
Assert.AreEqual(rFiles[1].FromFileSpec.Version, new VersionRange(1, 2));
Assert.AreEqual(rFiles[1].FromFileSpec.Version, new VersionRange(1, 2));
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
///A test for ReconcileFiles
///</summary>
[TestMethod()]
public void ReconcileFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
FileSpec folderRoot = new FileSpec(new LocalPath(@"C:\MyTestDir\admin_space\MyCode\..."),
null);
// force sync files
Options sFlags = new Options(SyncFilesCmdFlags.Force, -1);
IList<FileSpec> syncedFiles = con.Client.SyncFiles(sFlags, folderRoot);
// touch files under Perforce control without opening for
// add, edit or delete
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\pup.txt",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\pup.txt")
& ~FileAttributes.ReadOnly);
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt")
& ~FileAttributes.ReadOnly);
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\Silly.bmp",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\Silly.bmp")
& ~FileAttributes.ReadOnly);
// edit a file
var lines = System.IO.File.ReadAllLines(@"C:\MyTestDir\admin_space\MyCode\pup.txt");
lines[0] = "some value";
System.IO.File.WriteAllLines(@"C:\MyTestDir\admin_space\MyCode\pup.txt", lines);
// do nothing with ReadMe.txt
// delete a file
System.IO.File.Delete(@"C:\MyTestDir\admin_space\MyCode\Silly.bmp");
// create a file
System.IO.File.Create(@"C:\MyTestDir\admin_space\MyCode\new.txt").Close();
// status check for all added files
sFlags = new Options(ReconcileFilesCmdFlags.NotControlled, -1);
IList<FileSpec> rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(1, rFiles.Count);
// status check for all edited files
sFlags = new Options(ReconcileFilesCmdFlags.ModifiedOutside, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(1, rFiles.Count);
// status check for all deleted files
sFlags = new Options(ReconcileFilesCmdFlags.DeletedLocally, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(1, rFiles.Count);
// status check for all files
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(4, rFiles.Count);
// test reconcile against all files in a directory with no changelist specified
sFlags = new Options(ReconcileFilesCmdFlags.Preview, -1);
rFiles = con.Client.ReconcileFiles(sFlags, folderRoot);
Assert.IsNotNull(rFiles);
Assert.AreEqual(3, rFiles.Count);
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
rFiles = con.Client.ReconcileFiles(sFlags, folderRoot);
sFlags = new Options(GetFileMetadataCmdFlags.None, null,null,0,
null,null);
syncedFiles = new List<FileSpec>();
syncedFiles.Add(folderRoot);
// get the filemetadata to confirm reconcile opened the
// modified files with the correct action
IList<FileMetaData> fmd = rep.GetFileMetaData(syncedFiles,sFlags);
Assert.IsNotNull(fmd);
Assert.AreEqual(5, fmd.Count);
Assert.AreEqual(fmd[0].Action, FileAction.Add);
Assert.AreEqual(fmd[1].Action, FileAction.Add);
Assert.AreEqual(fmd[2].Action, FileAction.Edit);
Assert.AreEqual(fmd[3].Action, FileAction.None);
Assert.AreEqual(fmd[4].Action, FileAction.Delete);
// status with -A, which should return null since all
// files in this directory have been reconciled and
// p4 status -A == p4 reconcile -e -a -d
sFlags = new Options(ReconcileFilesCmdFlags.NotOpened, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.IsNull(rFiles);
}
}
finally
{
// delete created file
System.IO.File.Delete(@"C:\MyTestDir\admin_space\MyCode\new.txt");
// set untouched file back to read only
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
FileAttributes.ReadOnly);
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ReconcileFiles with a renamed file
///</summary>
[TestMethod()]
public void ReconcileRenamedFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
FileSpec folderRoot = new FileSpec(new LocalPath(@"C:\MyTestDir\admin_space\MyCode\..."),
null);
// force sync files
Options sFlags = new Options(SyncFilesCmdFlags.Force, -1);
IList<FileSpec> syncedFiles = con.Client.SyncFiles(sFlags, folderRoot);
// touch file under Perforce control without opening for
// add, edit or delete
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt")
& ~FileAttributes.ReadOnly);
// rename a file
System.IO.File.Move(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
@"C:\MyTestDir\admin_space\MyCode\RenamedReadMe.txt");
// status check for all added files
sFlags = new Options(ReconcileFilesCmdFlags.NotControlled, -1);
IList<FileSpec> rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(1, rFiles.Count);
// status check for all edited files
sFlags = new Options(ReconcileFilesCmdFlags.ModifiedOutside, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.IsNull(rFiles);
// status check for all deleted files
sFlags = new Options(ReconcileFilesCmdFlags.DeletedLocally, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(1, rFiles.Count);
// status check for all files
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(3, rFiles.Count);
// test reconcile against all files in a directory with no changelist specified
sFlags = new Options(ReconcileFilesCmdFlags.Preview, -1);
rFiles = con.Client.ReconcileFiles(sFlags, folderRoot);
Assert.IsNotNull(rFiles);
Assert.AreEqual(2, rFiles.Count);
// change folderRoot to limit to the renamed file
folderRoot = new FileSpec(new LocalPath(@"C:\MyTestDir\admin_space\MyCode\*ReadMe.txt"),
null);
// reconcile the renamed file
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
rFiles = con.Client.ReconcileFiles(sFlags, folderRoot);
sFlags = new Options(GetFileMetadataCmdFlags.None, null, null, 0,
null, null);
syncedFiles = new List<FileSpec>();
syncedFiles.Add(folderRoot);
// get the filemetadata to confirm reconcile opened the
// modified files with the correct action
IList<FileMetaData> fmd = rep.GetFileMetaData(syncedFiles, sFlags);
Assert.IsNotNull(fmd);
Assert.AreEqual(2, fmd.Count);
Assert.AreEqual(fmd[0].Action, FileAction.MoveDelete);
Assert.AreEqual(fmd[1].Action, FileAction.MoveAdd);
// status with -A, which should return null since all
// files in this directory have been reconciled and
// p4 status -A == p4 reconcile -e -a -d
sFlags = new Options(ReconcileFilesCmdFlags.NotOpened, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.IsNull(rFiles);
}
}
finally
{
// set renamed file back to read only and original name
System.IO.File.Move(@"C:\MyTestDir\admin_space\MyCode\RenamedReadMe.txt",
@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt");
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
FileAttributes.ReadOnly);
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ReconcileClean
///</summary>
[TestMethod()]
public void ReconcileCleanTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
// Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
FileSpec folderRoot = new FileSpec(new LocalPath(@"C:\MyTestDir\admin_space\MyCode\..."),
null);
// force sync files
Options sFlags = new Options(SyncFilesCmdFlags.Force, -1);
IList<FileSpec> syncedFiles = con.Client.SyncFiles(sFlags, folderRoot);
// touch files under Perforce control without opening for
// add, edit or delete
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\pup.txt",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\pup.txt")
& ~FileAttributes.ReadOnly);
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt")
& ~FileAttributes.ReadOnly);
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\Silly.bmp",
System.IO.File.GetAttributes(@"C:\MyTestDir\admin_space\MyCode\Silly.bmp")
& ~FileAttributes.ReadOnly);
// edit a file
var lines = System.IO.File.ReadAllLines(@"C:\MyTestDir\admin_space\MyCode\pup.txt");
lines[0] = "some value";
System.IO.File.WriteAllLines(@"C:\MyTestDir\admin_space\MyCode\pup.txt", lines);
// rename a file
System.IO.File.Move(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
@"C:\MyTestDir\admin_space\MyCode\RenamedReadMe.txt");
// delete a file
System.IO.File.Delete(@"C:\MyTestDir\admin_space\MyCode\Silly.bmp");
// create a file
System.IO.File.Create(@"C:\MyTestDir\admin_space\MyCode\new.txt").Close();
// check file differences (there should be some)
string[] args = new string[1];
args[0] = folderRoot.LocalPath.ToString();
Options options = new Options();
options["-f"] = null;
options["-sl"] = null;
P4Command cmd = new P4Command(con, "diff", true, args);
P4CommandResult results = cmd.Run(options);
// confirm diffs on edits or deletes
// (diff will not check for files existing
// locally that are not yet added
string value= "";
results.TaggedOutput[0].TryGetValue("status", out value);
Assert.AreEqual(value, "diff");
results.TaggedOutput[1].TryGetValue("status", out value);
Assert.AreEqual(value, "missing");
results.TaggedOutput[2].TryGetValue("status", out value);
Assert.AreEqual(value, "missing");
// status check for all files
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
IList<FileSpec> rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(6, rFiles.Count);
// test reconcile against all files in a directory with no changelist specified
sFlags = new Options(ReconcileFilesCmdFlags.Preview, -1);
rFiles = con.Client.ReconcileFiles(sFlags, folderRoot);
Assert.IsNotNull(rFiles);
Assert.AreEqual(5, rFiles.Count);
// run p4 clean on the directory
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
rFiles = con.Client.ReconcileClean(sFlags, folderRoot);
// check file differences (there should be none)
options = new Options();
options["-f"] = null;
options["-sl"] = null;
results = cmd.Run(options);
// confirm that all files match the depot file
results.TaggedOutput[0].TryGetValue("status", out value);
Assert.AreEqual(value, "same");
results.TaggedOutput[1].TryGetValue("status", out value);
Assert.AreEqual(value, "same");
results.TaggedOutput[2].TryGetValue("status", out value);
Assert.AreEqual(value, "same");
// status check for all files
// only the 2 unadded files should be returned
sFlags = new Options(ReconcileFilesCmdFlags.None, -1);
rFiles = con.Client.ReconcileStatus(sFlags, folderRoot);
Assert.AreEqual(1, rFiles.Count);
}
}
finally
{
// delete created file
System.IO.File.Delete(@"C:\MyTestDir\admin_space\MyCode\new.txt");
// set renamed file back to read only
System.IO.File.SetAttributes(@"C:\MyTestDir\admin_space\MyCode\ReadMe.txt",
FileAttributes.ReadOnly);
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for RevertFiles
///</summary>
[TestMethod()]
public void RevertFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
// test revert against all .txt files in a directory with no changelist specified
FileSpec fromFile = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*.txt")),
null);
Options sFlags = new Options(
RevertFilesCmdFlags.Preview,
-1
);
IList<FileSpec> rFiles = con.Client.RevertFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(3, rFiles.Count);
// test revert against all files in changelist 5 (1 marked for add)
fromFile = new FileSpec(new DepotPath("//..."), null);
sFlags = new Options(
RevertFilesCmdFlags.Preview,
5);
rFiles = con.Client.RevertFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
// test revert against all files in the default changelist (3 in total)
fromFile = new FileSpec(new DepotPath("//..."), null);
sFlags = new Options(
RevertFilesCmdFlags.Preview,
0);
rFiles = con.Client.RevertFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(3, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ShelveFiles
///</summary>
[TestMethod()]
public void ShelveFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist();
change.Description = "On the fly built change list";
FileMetaData file = new FileMetaData();
file.DepotPath = new DepotPath("//depot/TestData/Letters.txt");
change.Files.Add(file);
Options sFlags = new Options(
ShelveFilesCmdFlags.None,
change,
-1
);
IList<FileSpec> rFiles = con.Client.ShelveFiles(sFlags);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), null);
Options ops = new Options(9, null);
rFiles = con.Client.ReopenFiles(ops, fromFile);
Assert.AreEqual(1, rFiles.Count);
sFlags = new Options(
ShelveFilesCmdFlags.None,
null,
9 // created by last shelve command
);
rFiles = con.Client.ShelveFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for ShelveFiles with new options
///</summary>
[TestMethod()]
public void ShelveFilesTest2()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist();
change.Description = "On the fly built change list";
FileMetaData file = new FileMetaData();
file.DepotPath = new DepotPath("//depot/MyCode/pup.txt");
FileSpec fs = new FileSpec(file.DepotPath, null, null, null);
EditCmdOptions editOpts = new EditCmdOptions(EditFilesCmdFlags.None,
-1, null);
rep.Connection.Client.EditFiles(editOpts, fs);
change.Files.Add(file);
rep.SaveChangelist(change, null);
IList<FileSpec> rFiles = new List<FileSpec>();
ShelveFilesCmdOptions opts = new ShelveFilesCmdOptions(
ShelveFilesCmdFlags.LeaveUnchanged, null, 9);
try
{
rFiles = con.Client.ShelveFiles(opts, fs);
}
catch (P4Exception ex)
{
Assert.AreEqual(806428054, ex.ErrorCode,
"No files to shelve.\n");
}
// no file should be shelved here, so the list should be null or have
// no items
Assert.IsTrue((rFiles == null) || (0 == rFiles.Count));
opts = new ShelveFilesCmdOptions(
ShelveFilesCmdFlags.SubmitUnchanged | ShelveFilesCmdFlags.Force, null, 9);
try
{
rFiles = con.Client.ShelveFiles(opts, fs);
}
catch (P4Exception ex)
{
string msg = ex.Message;
Assert.Fail();
}
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for Parallel ShelveFiles
///</summary>
[TestMethod()]
public void ParallelShelveFilesTestA()
{
ParallelShelveFilesTest(true);
}
[TestMethod()]
public void ParallelShelveFilesTestU()
{
ParallelShelveFilesTest(false);
}
public void ParallelShelveFilesTest(bool unicode)
{
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
int fileCount = 500; // remember that this is an unlicensed server
Process p4d = null;
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
string clientDir = Path.Combine(TestDir, ws_client);
string syncFilesDir = Path.Combine(clientDir, "parallel");
FileSpec parallelFileSpec = FileSpec.ClientSpec(syncFilesDir + "\\...");
var parallelFileSpecArray = new FileSpec[] { parallelFileSpec };
FileSpec parallelFileSpecZero = FileSpec.ClientSpec(syncFilesDir + "\\...", VersionSpec.None);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
// Set up a bunch of files in the workspace
PrepSyncFiles(syncFilesDir);
CreateSyncFiles(syncFilesDir, fileCount);
Changelist change = new Changelist();
change.Description = "On the fly built change list";
Changelist newChange = rep.CreateChangelist(change, null);
// Add them to the server
Options addFlags = new Options(AddFilesCmdFlags.None, newChange.Id, null);
IList<FileSpec> addFiles = con.Client.AddFiles(addFlags, parallelFileSpecArray);
Options sFlags = new ShelveFilesCmdOptions(
ShelveFilesCmdFlags.DisableParallel, null,
newChange.Id);
IList<FileSpec> rFiles = con.Client.ShelveFiles(sFlags);
// confirm that cmd flags were passed to disable parallel
string[] lastResults = con.LastResults.CmdArgs;
Assert.IsTrue((Array.IndexOf(lastResults, "--parallel")) > -1);
Assert.IsTrue((Array.IndexOf(lastResults, "0")) > -1);
// delete the shelved files
sFlags = new ShelveFilesCmdOptions(
ShelveFilesCmdFlags.Delete, null
,
newChange.Id);
con.Client.ShelveFiles(sFlags);
// now shelve them with parallel
sFlags = new ShelveFilesCmdOptions(
ShelveFilesCmdFlags.None, null
,
newChange.Id, 0, 4, 10, 0, 100
);
rFiles = con.Client.ShelveFiles(sFlags);
// confirm that no cmd flags were passed to disable parallel
lastResults = con.LastResults.CmdArgs;
Assert.IsFalse((Array.IndexOf(lastResults, "--parallel")) > -1);
Assert.IsFalse((Array.IndexOf(lastResults, "0")) > -1);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
///A test for SyncFiles
///</summary>
[TestMethod()]
public void SyncFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "Alex";
string pass = string.Empty;
string ws_client = "alex_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("Alex", con.Client.OwnerName);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/..."), null);
Options sFlags = new Options(
SyncFilesCmdFlags.Preview,
100
);
IList<FileSpec> rFiles = con.Client.SyncFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(6, rFiles.Count);
fromFile = new FileSpec(new DepotPath("//depot/MyCode2/*"), null);
sFlags = new Options(
SyncFilesCmdFlags.Force,
1
);
rFiles = con.Client.SyncFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for Parallel Sync
///</summary>
[TestMethod()]
public void ParallelSyncFilesTestA()
{
ParallelSyncFilesTest(false);
}
/// <summary>
///A test for Parallel Sync
///</summary>
[TestMethod()]
public void ParallelSyncFilesTestU()
{
ParallelSyncFilesTest(true);
}
public void ParallelSyncFilesTest(bool unicode)
{
string uri = "localhost:6666";
string user = "Alex";
string pass = string.Empty;
string ws_client = "alex_space";
int fileCount = 500; // remember that this is an unlicensed server
Process p4d = null;
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
string clientDir = Path.Combine(TestDir, ws_client);
string syncFilesDir = Path.Combine(clientDir, "parallel");
FileSpec parallelFileSpec = FileSpec.ClientSpec(syncFilesDir + "\\...");
var parallelFileSpecArray = new FileSpec[] { parallelFileSpec };
FileSpec parallelFileSpecZero = FileSpec.ClientSpec(syncFilesDir + "\\...", VersionSpec.None);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("Alex", con.Client.OwnerName);
// Set up a bunch of files in the workspace
PrepSyncFiles(syncFilesDir);
CreateSyncFiles(syncFilesDir, fileCount);
// Add them to the server
Options addFlags = new Options(AddFilesCmdFlags.None, -1, null);
IList<FileSpec> addFiles = con.Client.AddFiles(addFlags, parallelFileSpecArray);
// Submit them
Options submitFlags = new Options(SubmitFilesCmdFlags.None,-1, null,"initial submit test files", null);
con.Client.SubmitFiles(submitFlags, parallelFileSpec);
// Now Sync them all to NONE
Options syncFlags = new Options(SyncFilesCmdFlags.Quiet);
IList<FileSpec> syncFiles = con.Client.SyncFiles(syncFlags, parallelFileSpecZero);
bool setRv = P4ConfigureSetParallel(con, 4);
Assert.IsTrue(setRv);
// Finally, we Sync them again using parallel.
Options pFlags = new SyncFilesCmdOptions(SyncFilesCmdFlags.None, 0, 4, 10, 0, 100);
IList<FileSpec> pFiles = con.Client.SyncFiles(pFlags, parallelFileSpecArray);
Assert.IsNotNull(pFiles);
Assert.AreEqual(fileCount, pFiles.Count);
}
}
catch (P4Exception ex)
{
logger.Error("ParallelSyncFilesTest " + ex.Message, ex);
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
/// Create random byte array for file contents
/// </summary>
/// <param name="i">seed</param>
/// <returns>contents</returns>
private static byte[] GetFileContent(int i)
{
Random r = new Random(i);
byte[] buffer = new byte[1024];
r.NextBytes(buffer);
return buffer;
}
/// <summary>
/// Create a lot of random files
/// </summary>
/// <param name="folder">folder for files</param>
/// <param name="count">number of files to create</param>
private static void CreateSyncFiles(string folder, int count)
{
var sw = new Stopwatch();
sw.Start();
Parallel.For(0, count, (i) =>
{
string path = Path.Combine(folder, string.Format("file{0}.dat", i));
System.IO.File.WriteAllBytes(path, GetFileContent(i));
});
Console.WriteLine("Create {0} files, Time: {1}ms", count, sw.ElapsedMilliseconds);
}
private static void PrepSyncFiles(string folder)
{
if (Directory.Exists(folder))
{
var directory = new DirectoryInfo(folder) { Attributes = FileAttributes.Normal };
foreach (var info in directory.GetFileSystemInfos("*", SearchOption.AllDirectories))
{
info.Attributes = FileAttributes.Normal;
}
directory.Delete(true);
}
Directory.CreateDirectory(folder);
}
/// <summary>
/// Configure the server to use N threads
/// Log in as "admin" and run "p4 configure set net.parallel.max=N"
/// </summary>
/// <param name="con">Connection to server</param>
/// <param name="threads">Max number of parallel threads</param>
/// <returns>true if no error</returns>
private bool P4ConfigureSetParallel(Connection con, int threads)
{
string oldUser = con.UserName;
con.UserName = "admin";
con.Login("");
// Tell the server to support parallel
string[] args = {"set", "net.parallel.max=" + threads };
var cmd = new P4Command(con, "configure", false, args);
var cmdr = cmd.Run(new Options());
// now force a reconnect, or p4d might not use the new config
con.getP4Server().Reconnect();
con.UserName = oldUser;
return cmdr.Success;
}
private bool P4Configure(Connection con, string[] args)
{
string oldUser = con.UserName;
con.UserName = "admin";
con.Login("");
var cmd = new P4Command(con, "configure", false, args);
var cmdr = cmd.Run(new Options());
con.UserName = oldUser;
return cmdr.Success;
}
/// <summary>
///A test for Parallel Sync error handling
/// Job085941
///</summary>
[TestMethod()]
public void ParallelSyncJob085941A()
{
ParallelSyncJob085941(false);
}
/// <summary>
/// A test for Parallel Sync error handling (don't run for unicode, u.exe lacks an alex_space that the test depends on)
/// Job085941
///</summary>
/*
[TestMethod()]
public void ParallelSyncJob085941U()
{
// ParallelSyncJob085941(true);
}
*/
public void ParallelSyncJob085941(bool unicode)
{
string uri = "localhost:6666";
string user1 = "Alex";
string pass = string.Empty;
string ws_client1 = "alex_space";
string user2 = "Alice";
string ws_client2 = "alice_space";
string targetFile = "file59.dat";
int fileCount = 500; // remember that this is an unlicensed server
Process p4d = null;
Connection con = null;
P4CommandResult cmdResult;
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
// Information about Alex's workspace
string clientDir1 = Path.Combine(TestDir, ws_client1);
string syncFilesDir1 = Path.Combine(clientDir1, "parallel");
string testFile1 = Path.Combine(syncFilesDir1, targetFile);
FileSpec parallelFileSpec1 = FileSpec.ClientSpec(syncFilesDir1 + "\\...");
var parallelFileSpecArray1 = new FileSpec[] { parallelFileSpec1 };
FileSpec parallelFileSpecZero1 = FileSpec.ClientSpec(syncFilesDir1 + "\\...", VersionSpec.None);
FileSpec testFileSpec1 = FileSpec.ClientSpec(testFile1);
var testFileSpecArray1 = new FileSpec[] { testFileSpec1 };
// Information about Alice's workspace
string clientDir2 = Path.Combine(TestDir, ws_client2);
string syncFilesDir2 = Path.Combine(clientDir2, "parallel");
string testFile2 = Path.Combine(syncFilesDir2, targetFile);
FileSpec parallelFileSpec2 = FileSpec.ClientSpec(syncFilesDir2 + "\\...");
FileSpec testFileSpec2 = FileSpec.ClientSpec(testFile2);
var testFileSpecArray2 = new FileSpec[] { testFileSpec2 };
using (con = rep.Connection)
{
con.UserName = user1;
con.Client = new Client {Name = ws_client1};
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("Alex", con.Client.OwnerName);
// Set up a bunch of files in the workspace
PrepSyncFiles(syncFilesDir1);
CreateSyncFiles(syncFilesDir1, fileCount);
// Add them to the server
Options addFlags = new Options(AddFilesCmdFlags.None, -1, null);
IList<FileSpec> addFiles = con.Client.AddFiles(addFlags, parallelFileSpecArray1);
// Submit them
Options submitFlags = new Options(SubmitFilesCmdFlags.None, -1, null, "initial submit test files", null);
con.Client.SubmitFiles(submitFlags, parallelFileSpec1);
// Remove all Workspace Files (Sync to NONE)
Options syncFlags = new Options(SyncFilesCmdFlags.Quiet);
IList<FileSpec> syncFiles = con.Client.SyncFiles(syncFlags, parallelFileSpecZero1);
// Sync just the target file
syncFlags = new Options(SyncFilesCmdFlags.Quiet | SyncFilesCmdFlags.Force);
IList<FileSpec> syncOneFile = con.Client.SyncFiles(syncFlags, testFileSpecArray1);
// Change Target file to Read Only
var fileInfo = new System.IO.FileInfo(testFile1){ IsReadOnly = false };
// Now set up the other user / client
con.UserName = user2;
con.Client = new Client { Name = ws_client2 };
// Sync just the target file
syncFlags = new Options(SyncFilesCmdFlags.Quiet | SyncFilesCmdFlags.Force);
IList<FileSpec> syncOneFile2 = con.Client.SyncFiles(syncFlags, testFileSpecArray2);
// Edit the TargetFile
Options editFlags = new Options();
IList<FileSpec> editFiles = con.Client.EditFiles(editFlags, testFileSpecArray2 );
System.IO.File.WriteAllBytes(testFile2, GetFileContent(99));
// Submit the targetfile2
submitFlags = new Options(SubmitFilesCmdFlags.None, -1, null, "update test file", null);
con.Client.SubmitFiles(submitFlags, parallelFileSpec2);
// Back to the original user / workspace
con.UserName = user1;
con.Client = new Client { Name = ws_client1 };
// Add debugging to server log
string[] cargs = new string[]{"set", "dmc=3"};
P4Configure(con, cargs);
bool setRv = P4ConfigureSetParallel(con, 4);
Assert.IsTrue(setRv);
// Finally, we Sync them again using parallel.
Options pFlags = new SyncFilesCmdOptions(SyncFilesCmdFlags.None, 0, 4, 8, 2000, 9, 2000);
IList<FileSpec> pFiles = con.Client.SyncFiles(pFlags, parallelFileSpecArray1);
cmdResult = con.LastResults;
Assert.IsNotNull(pFiles);
Assert.AreEqual(fileCount, pFiles.Count);
}
}
catch (P4Exception ex)
{
logger.Error("ParallelSyncJob085941: " + ex.Message, ex);
Assert.AreEqual(0, ex.ErrorCode, "Error undetected during parallel sync\n");
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
///A test for SyncFiles using a label
///</summary>
[TestMethod()]
public void SyncToLabelTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/..."), new LabelNameVersion("admin_label"));
Options sFlags = new Options(
SyncFilesCmdFlags.Preview,
100
);
IList<FileSpec> rFiles = con.Client.SyncFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
if (i == 0)
{
Assert.AreEqual(10, rFiles.Count);
}
else
{
Assert.AreEqual(6, rFiles.Count);
}
IList<FileMetaData> fmd = rep.GetFileMetaData(null, fromFile);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for SyncParallelErrorjob095320
///</summary>
[TestMethod()]
public void SyncParallelErrorTestjob095320()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 13, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
Connection con = rep.Connection;
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
con.Connect(null);
FileSpec fs = new FileSpec();
fs.DepotPath = new DepotPath("//depot/...");
Options sFlags = new Options(
SyncFilesCmdFlags.DisableParallel,
100
);
// Some of the files we need to work with are
// checked out, so revert them.
IList<FileSpec> rFiles = con.Client.RevertFiles(null, fs);
// Make one of the files at Rev 1 of 2 writeable
System.IO.File.SetAttributes(rFiles[5].LocalPath.Path, FileAttributes.Normal);
// modify the file
System.IO.File.WriteAllText(rFiles[5].LocalPath.Path, DateTime.Now.ToLongDateString());
// Now attempt to sync that file
try
{
var resp = rep.Connection.Client.SyncFiles(sFlags, new FileSpec(new DepotPath(@"//depot/TestData/Numbers.txt")));
}
catch (Exception e)
{
// This sync should fail on a "can't clobber" error
Assert.IsTrue(e.Message.Contains("Can't clobber writable file"));
}
// Confirm the other reverted file to still be at rev 1
IList<FileMetaData> fmd = rep.GetFileMetaData(null, new FileSpec(new DepotPath(@"//depot/TestData/WingDings.txt")));
Assert.AreEqual(fmd[0].HaveRev.ToString(), "1");
try
{
rep.Connection.Client.SyncFiles(sFlags, new FileSpec(new DepotPath(@"//depot/TestData/WingDings.txt")));
}
catch (Exception e)
{
if (e.Message.Contains("parallel"))
{
throw e;
}
}
// Confirm the other reverted file to be at rev 2 (sync succeeded)
fmd = rep.GetFileMetaData(null, new FileSpec(new DepotPath(@"//depot/TestData/WingDings.txt")));
Assert.AreEqual(fmd[0].HaveRev.ToString(),"2");
// now disconnect since this is not wrapped in a using statement
con.Disconnect();
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
}
/// <summary>
///A test for SyncFiles syncing a file that has been deleted from the depot
///</summary>
[TestMethod()]
public void SyncDeletedFileTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 8, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual(user, con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
// mark the file for delete and submit the change
FileSpec fromFile = new FileSpec(new DepotPath("//depot/Modifiers/Silly.bmp"), null);
FileSpec toFile = new FileSpec(new DepotPath("//depot/Modifiers/Silly.bmp"), new Revision(1));
con.Client.DeleteFiles(null, fromFile);
Options submitOpts = new Options(SubmitFilesCmdFlags.None, -1, null, "Delete a file",
null);
con.Client.SubmitFiles(submitOpts, fromFile);
// sync to a version of the file that was note deleted
IList<FileSpec> rFiles = con.Client.SyncFiles(null, toFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
// sync to the head version (deleted)
rFiles = con.Client.SyncFiles(null, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
// make sure the file was removed from the workspace
Assert.IsFalse(System.IO.File.Exists(Path.Combine(adminSpace, "Modifiers\\Silly.bmp")));
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for UnlockFiles
///</summary>
[TestMethod()]
public void UnlockFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 2; i++) // run once for ascii, once for unicode
{
try {
p4d = Utilities.DeployP4TestServer(TestDir, 5, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
IList<FileSpec> oldfiles = con.Client.LockFiles(null);
Assert.AreNotEqual(null, oldfiles);
oldfiles = con.Client.UnlockFiles(null);
Assert.AreNotEqual(null, oldfiles);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for UnshelveFiles
///</summary>
[TestMethod()]
public void UnshelveFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
var clientRoot = Utilities.TestClientRoot(TestDir, unicode);
var adminSpace = Path.Combine(clientRoot, "admin_space");
Directory.CreateDirectory(adminSpace);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
Utilities.SetClientRoot(rep, TestDir, unicode, ws_client);
Changelist change = new Changelist();
change.Description = "On the fly built change list";
FileMetaData file = new FileMetaData();
file.DepotPath = new DepotPath("//depot/TestData/Letters.txt");
change.Files.Add(file);
Options sFlags = new Options(
ShelveFilesCmdFlags.None,
change,
-1
);
IList<FileSpec> rFiles = con.Client.ShelveFiles(sFlags);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), null);
Options ops = new Options(9, null);
rFiles = con.Client.ReopenFiles(ops, fromFile);
Assert.AreEqual(1, rFiles.Count);
sFlags = new Options(
ShelveFilesCmdFlags.None,
null,
9 // created by last shelve command
);
rFiles = con.Client.ShelveFiles(sFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
FileSpec revertFiles = new FileSpec(new LocalPath(Path.Combine(adminSpace, "TestData\\*")), null);
Options rFlags = new Options(
RevertFilesCmdFlags.None,
9
);
rFiles = con.Client.RevertFiles(rFlags, revertFiles);
Options uFlags =
new Options(UnshelveFilesCmdFlags.None, 9, -1);
rFiles = con.Client.UnshelveFiles(uFlags, fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
rFiles = con.Client.UnshelveFiles(uFlags);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for GetClientFileMappings
///</summary>
[TestMethod()]
public void GetClientFileMappingsTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), null);
IList<FileSpec> rFiles = con.Client.GetClientFileMappings(fromFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for CopyFiles
///</summary>
[TestMethod()]
public void CopyFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), null);
FileSpec toFile = new FileSpec(new DepotPath("//depot/TestData42/Numbers.txt"), null);
IList<FileSpec> rFiles = con.Client.CopyFiles(null, fromFile, toFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
fromFile = new FileSpec(new DepotPath("//depot/TestData/*"), null);
toFile = new FileSpec(new DepotPath("//depot/TestData44/*"), null);
Options cFlags = new Options(
CopyFilesCmdFlags.Virtual, null, null, null, -1, 2
);
rFiles = con.Client.CopyFiles(cFlags, fromFile, toFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(2, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
/// <summary>
///A test for MergeFiles
///</summary>
[TestMethod()]
public void MergeFilesTest()
{
bool unicode = false;
string uri = "localhost:6666";
string user = "admin";
string pass = string.Empty;
string ws_client = "admin_space";
Process p4d = null;
for (int i = 0; i < 1; i++) // run once for ascii, once for unicode
{
try
{
p4d = Utilities.DeployP4TestServer(TestDir, 2, unicode);
Server server = new Server(new ServerAddress(uri));
Repository rep = new Repository(server);
using (Connection con = rep.Connection)
{
con.UserName = user;
con.Client = new Client();
con.Client.Name = ws_client;
Assert.AreEqual(con.Status, ConnectionStatus.Disconnected);
Assert.AreEqual(con.Server.State, ServerState.Unknown);
Assert.IsTrue(con.Connect(null));
Assert.AreEqual(con.Server.State, ServerState.Online);
Assert.AreEqual(con.Status, ConnectionStatus.Connected);
Assert.AreEqual("admin", con.Client.OwnerName);
FileSpec fromFile = new FileSpec(new DepotPath("//depot/TestData/Numbers.txt"), null);
FileSpec toFile = new FileSpec(new DepotPath("//depot/TestData42/Numbers.txt"), null);
IList<FileSpec> rFiles = con.Client.MergeFiles(null, fromFile, toFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(1, rFiles.Count);
fromFile = new FileSpec(new DepotPath("//depot/TestData/*"), null);
toFile = new FileSpec(new DepotPath("//depot/TestData44/*"), null);
Options cFlags = new Options(
MergeFilesCmdFlags.Force, null, null, null, -1, 2
);
rFiles = con.Client.MergeFiles(cFlags, fromFile, toFile);
Assert.IsNotNull(rFiles);
Assert.AreEqual(2, rFiles.Count);
}
}
finally
{
Utilities.RemoveTestServer(p4d, TestDir);
}
unicode = !unicode;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink