public void WhenStagingFileApplyIsCalledWithCleanForCorrectPath()
{
string repoPath = InitNewRepository();
bool called = false;
Action <Stream, Stream> clean = (reader, writer) =>
{
called = true;
reader.CopyTo(writer);
};
var filter = new FakeFilter(FilterName, attributes, clean);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
using (var repo = CreateTestRepository(repoPath))
{
StageNewFile(repo);
Assert.True(called);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public static void RunlUpdate(EnvDTE.Project project)
{
QtProject qtPro = QtProject.Create(project);
if (qtPro == null)
{
return;
}
FakeFilter ts = Filters.TranslationFiles();
VCFilter tsFilter = qtPro.FindFilterFromGuid(ts.UniqueIdentifier);
if (tsFilter == null)
{
return;
}
IVCCollection files = tsFilter.Files as IVCCollection;
foreach (VCFile file in files)
{
VCFile vcFile = file as VCFile;
if (HelperFunctions.IsTranslationFile(vcFile))
{
if (!RunlUpdate(vcFile, project))
{
return;
}
}
}
}
public void WhenCheckingOutAFileFileSmudgeWritesCorrectFileToWorkingDirectory()
{
const string decodedInput = "This is a substitution cipher";
const string encodedInput = "Guvf vf n fhofgvghgvba pvcure";
const string branchName = "branch";
string repoPath = InitNewRepository();
Action <Stream, Stream> smudgeCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
var filter = new FakeFilter(FilterName, attributes, null, smudgeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
FileInfo expectedFile = CheckoutFileForSmudge(repoPath, branchName, encodedInput);
string combine = Path.Combine(repoPath, "..", expectedFile.Name);
string readAllText = File.ReadAllText(combine);
Assert.Equal(decodedInput, readAllText);
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void CleanFilterWritesOutputToObjectTree()
{
const string decodedInput = "This is a substitution cipher";
const string encodedInput = "Guvf vf n fhofgvghgvba pvcure";
string repoPath = InitNewRepository();
Action <Stream, Stream> cleanCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
var filter = new FakeFilter(FilterName, attributes, cleanCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
using (var repo = CreateTestRepository(repoPath))
{
FileInfo expectedFile = StageNewFile(repo, decodedInput);
var commit = repo.Commit("Clean that file", Constants.Signature, Constants.Signature);
var blob = (Blob)commit.Tree[expectedFile.Name].Target;
var textDetected = blob.GetContentText();
Assert.Equal(encodedInput, textDetected);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void InitCallbackMadeWhenUsingTheFilter()
{
bool called = false;
Action initializeCallback = () =>
{
called = true;
};
var filter = new FakeFilter(FilterName,
attributes,
successCallback,
successCallback,
initializeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
Assert.False(called);
string repoPath = InitNewRepository();
using (var repo = CreateTestRepository(repoPath))
{
StageNewFile(repo);
Assert.True(called);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void SetUp()
{
_filter = new FakeFilter();
_filters = new List <Filter>();
_mockContext = new Mock <IDataContext>();
_mockContext.Setup(p => p.Filters).Returns(_filters);
_repository = new FilterRepository(_mockContext.Object);
}
public static FakeFilter FormFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}";
f.Name = SR.GetString("Resources_FormFiles");
f.Filter = "ui";
return(f);
}
public static FakeFilter HeaderFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{93995380-89BD-4b04-88EB-625FBE52EBFB}";
f.Name = SR.GetString("Resources_HeaderFiles");
f.Filter = "h";
return(f);
}
public static FakeFilter SourceFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}";
f.Name = SR.GetString("Resources_SourceFiles");
f.Filter = "cpp;cxx;c;def";
return(f);
}
public static FakeFilter OtherFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{B67473BF-9FA1-4674-831E-CB28F72D4791}";
f.Name = SR.GetString("Resources_OtherFiles");
f.Filter = "*";
f.SCCFiles = false;
return(f);
}
public static FakeFilter GeneratedFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}";
f.Name = SR.GetString("Resources_GeneratedFiles");
f.Filter = "moc;h;cpp";
f.SCCFiles = false;
return(f);
}
public static FakeFilter TranslationFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}";
f.Name = SR.GetString("Resources_TranslationFiles");
f.Filter = "ts";
f.ParseFiles = false;
return(f);
}
public static FakeFilter ResourceFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}";
f.Name = SR.GetString("Resources_ResourceFiles");
f.ParseFiles = false;
f.Filter = "qrc;*";
return(f);
}
public void SetUp()
{
_filter = new FakeFilter();
_filterViewModel = new FakeFilterViewModel(_filter);
_mockQueryBus = new Mock <IQueryBus>();
_mockQueryBus.Setup(p => p.Execute(It.IsAny <GetFiltersQuery>()))
.Returns(new List <Domain.Filters.Filter> {
_filter
});
_mockFactory = new Mock <IFilterViewModelFactory>();
_mockFactory.Setup(p => p.Create(_filter)).Returns(_filterViewModel);
_viewModel = new FilterPaneViewModel(
_mockQueryBus.Object,
_mockFactory.Object);
}
public void SetUp()
{
_newFilter = new FakeFilter();
_oldFilter = new FakeFilter();
_node = new FakeFilterTreeNode(_newFilter);
_mockRepository = new Mock <IFilterRepository>();
_mockService = new Mock <IApplicationStateService>();
_mockService.Setup(p => p.GetSelectedFilter()).Returns(_oldFilter);
_mockEventBus = new Mock <IEventBus>();
_handler = new SelectFilterTreeNodeCommandHandler(
_mockRepository.Object,
_mockService.Object,
_mockEventBus.Object);
}
public void SetUp()
{
_filter = new FakeFilter();
_row = new RowBuilder().Build();
_rows = new List <Row> {
_row
};
_mockState = new Mock <IApplicationState>();
_mockState.SetupGet(p => p.IsStartMenuVisible).Returns(true);
_mockState.SetupGet(p => p.IsNavigationTreeVisible).Returns(true);
_mockState.SetupGet(p => p.SelectedFilter).Returns(_filter);
_mockState.SetupGet(p => p.SelectedRows).Returns(_rows);
_mockEventBus = new Mock <IEventBus>();
_service = new ApplicationStateService(
_mockState.Object,
_mockEventBus.Object);
}
public void CanHandleMultipleSmudgesConcurrently()
{
const string decodedInput = "This is a substitution cipher";
const string encodedInput = "Guvf vf n fhofgvghgvba pvcure";
const string branchName = "branch";
Action <Stream, Stream> smudgeCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
var filter = new FakeFilter(FilterName, attributes, null, smudgeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
int count = 30;
var tasks = new Task <FileInfo> [count];
for (int i = 0; i < count; i++)
{
tasks[i] = Task.Factory.StartNew(() =>
{
string repoPath = InitNewRepository();
return(CheckoutFileForSmudge(repoPath, branchName, encodedInput));
});
}
Task.WaitAll(tasks);
foreach (var task in tasks)
{
FileInfo expectedFile = task.Result;
string readAllText = File.ReadAllText(expectedFile.FullName);
Assert.Equal(decodedInput, readAllText);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void InitCallbackNotMadeWhenFilterNeverUsed()
{
bool called = false;
Action initializeCallback = () =>
{
called = true;
};
var filter = new FakeFilter(FilterName,
attributes,
successCallback,
successCallback,
initializeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
Assert.False(called);
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public FakeFilterTreeNode(FakeFilter filter) : base(null, null)
{
_filter = filter;
}
public static FakeFilter SourceFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{4FC737F1-C7A5-4376-A066-2A32D752A2FF}";
f.Name = SR.GetString("Resources_SourceFiles");
f.Filter = "cpp;cxx;c;def";
return f;
}
public static FakeFilter HeaderFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{93995380-89BD-4b04-88EB-625FBE52EBFB}";
f.Name = SR.GetString("Resources_HeaderFiles");
f.Filter = "h";
return f;
}
public void ProjectItemsEvents_ItemAdded(ProjectItem projectItem)
{
Project project = HelperFunctions.GetSelectedQtProject(VSPackage.dte);
QtProject qtPro = QtProject.Create(project);
if (!HelperFunctions.IsQtProject(project))
{
return;
}
VCFilter filter = null;
VCFile vcFile = GetVCFileFromProject(projectItem.Name, qtPro.VCProject);
if (vcFile == null)
{
return;
}
try
{
// Try to find the filter, the file is located in
// If the file is not inside any filter, move it to
// the according one, used by the Add-in
filter = (VCFilter)vcFile.Parent;
}
catch { }
try
{
FakeFilter ui = Filters.FormFiles();
FakeFilter qrc = Filters.ResourceFiles();
FakeFilter ts = Filters.TranslationFiles();
FakeFilter h = Filters.HeaderFiles();
FakeFilter src = Filters.SourceFiles();
VCFilter uiFilter = qtPro.FindFilterFromGuid(ui.UniqueIdentifier);
VCFilter tsFilter = qtPro.FindFilterFromGuid(ts.UniqueIdentifier);
VCFilter qrcFilter = qtPro.FindFilterFromGuid(qrc.UniqueIdentifier);
VCFilter hFilter = qtPro.FindFilterFromGuid(h.UniqueIdentifier);
VCFilter srcFilter = qtPro.FindFilterFromGuid(src.UniqueIdentifier);
if (HelperFunctions.HasSourceFileExtension(vcFile.Name))
{
if (vcFile.Name.ToLower().StartsWith("moc_"))
{
return;
}
else if (vcFile.Name.ToLower().StartsWith("qrc_"))
{
// Do not use precompiled headers with these files
QtProject.SetPCHOption(vcFile, pchOption.pchNone);
return;
}
string pcHeaderThrough = qtPro.GetPrecompiledHeaderThrough();
if (pcHeaderThrough != null)
{
string pcHeaderCreator = pcHeaderThrough.Remove(pcHeaderThrough.LastIndexOf('.')) + ".cpp";
if (vcFile.Name.ToLower().EndsWith(pcHeaderCreator.ToLower()) &&
HelperFunctions.CxxFileContainsNotCommented(vcFile, "#include \"" + pcHeaderThrough + "\"", false, false))
{
//File is used to create precompiled headers
QtProject.SetPCHOption(vcFile, pchOption.pchCreateUsingSpecific);
return;
}
}
if (filter == null && !HelperFunctions.IsInFilter(vcFile, src))
{
if (null == srcFilter && qtPro.VCProject.CanAddFilter(src.Name))
{
srcFilter = (VCFilter)qtPro.VCProject.AddFilter(src.Name);
srcFilter.Filter = src.Filter;
srcFilter.ParseFiles = src.ParseFiles;
srcFilter.UniqueIdentifier = src.UniqueIdentifier;
}
qtPro.RemoveItem(projectItem);
qtPro.AddFileToProject(vcFile.FullPath, src);
}
if (HelperFunctions.HasQObjectDeclaration(vcFile))
{
//#if (VS2010 || VS2012 || VS2013 || VS2015)
HelperFunctions.EnsureCustomBuildToolAvailable(projectItem);
//#endif
qtPro.AddMocStep(vcFile);
}
}
else if (HelperFunctions.HasHeaderFileExtension(vcFile.Name))
{
if (vcFile.Name.ToLower().StartsWith("ui_"))
{
return;
}
if (filter == null && !HelperFunctions.IsInFilter(vcFile, h))
{
if (null == hFilter && qtPro.VCProject.CanAddFilter(h.Name))
{
hFilter = (VCFilter)qtPro.VCProject.AddFilter(h.Name);
hFilter.Filter = h.Filter;
hFilter.ParseFiles = h.ParseFiles;
hFilter.UniqueIdentifier = h.UniqueIdentifier;
}
qtPro.RemoveItem(projectItem);
qtPro.AddFileToProject(vcFile.FullPath, h);
}
if (HelperFunctions.HasQObjectDeclaration(vcFile))
{
//#if (VS2010 || VS2012 || VS2013 || VS2015)
HelperFunctions.EnsureCustomBuildToolAvailable(projectItem);
//#endif
qtPro.AddMocStep(vcFile);
}
}
else if (vcFile.Name.EndsWith(".ui"))
{
if (filter == null && !HelperFunctions.IsInFilter(vcFile, ui))
{
if (null == uiFilter && qtPro.VCProject.CanAddFilter(ui.Name))
{
uiFilter = (VCFilter)qtPro.VCProject.AddFilter(ui.Name);
uiFilter.Filter = ui.Filter;
uiFilter.ParseFiles = ui.ParseFiles;
uiFilter.UniqueIdentifier = ui.UniqueIdentifier;
}
qtPro.RemoveItem(projectItem);
qtPro.AddFileToProject(vcFile.FullPath, ui);
}
//#if (VS2010 || VS2012 || VS2013 || VS2015)
HelperFunctions.EnsureCustomBuildToolAvailable(projectItem);
//#endif
qtPro.AddUic4BuildStep(vcFile);
}
else if (vcFile.Name.EndsWith(".qrc"))
{
if (filter == null && !HelperFunctions.IsInFilter(vcFile, qrc))
{
if (null == qrcFilter && qtPro.VCProject.CanAddFilter(qrc.Name))
{
qrcFilter = (VCFilter)qtPro.VCProject.AddFilter(qrc.Name);
qrcFilter.Filter = qrc.Filter;
qrcFilter.ParseFiles = qrc.ParseFiles;
qrcFilter.UniqueIdentifier = qrc.UniqueIdentifier;
}
qtPro.RemoveItem(projectItem);
qtPro.AddFileToProject(vcFile.FullPath, qrc);
}
//#if (VS2010 || VS2012 || VS2013 || VS2015)
HelperFunctions.EnsureCustomBuildToolAvailable(projectItem);
//#endif
qtPro.UpdateRccStep(vcFile, null);
}
else if (HelperFunctions.IsTranslationFile(vcFile))
{
if (filter == null && !HelperFunctions.IsInFilter(vcFile, ts))
{
if (null == tsFilter && qtPro.VCProject.CanAddFilter(ts.Name))
{
tsFilter = (VCFilter)qtPro.VCProject.AddFilter(ts.Name);
tsFilter.Filter = ts.Filter;
tsFilter.ParseFiles = ts.ParseFiles;
tsFilter.UniqueIdentifier = ts.UniqueIdentifier;
}
qtPro.RemoveItem(projectItem);
qtPro.AddFileToProject(vcFile.FullPath, ts);
}
}
}
catch { }
return;
}
public static FakeFilter FormFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{99349809-55BA-4b9d-BF79-8FDBB0286EB3}";
f.Name = SR.GetString("Resources_FormFiles");
f.Filter = "ui";
return f;
}
public static FakeFilter GeneratedFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{71ED8ED8-ACB9-4CE9-BBE1-E00B30144E11}";
f.Name = SR.GetString("Resources_GeneratedFiles");
f.Filter = "moc;h;cpp";
f.SCCFiles = false;
return f;
}
public void CanHandleMultipleSmudgesConcurrently()
{
const string decodedInput = "This is a substitution cipher";
const string encodedInput = "Guvf vf n fhofgvghgvba pvcure";
const string branchName = "branch";
Action<Stream, Stream> smudgeCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
var filter = new FakeFilter(FilterName, attributes, null, smudgeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
int count = 30;
var tasks = new Task<FileInfo>[count];
for (int i = 0; i < count; i++)
{
tasks[i] = Task.Factory.StartNew(() =>
{
string repoPath = InitNewRepository();
return CheckoutFileForSmudge(repoPath, branchName, encodedInput);
});
}
Task.WaitAll(tasks);
foreach(var task in tasks)
{
FileInfo expectedFile = task.Result;
string readAllText = File.ReadAllText(expectedFile.FullName);
Assert.Equal(decodedInput, readAllText);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void CleanFilterWritesOutputToObjectTree()
{
const string decodedInput = "This is a substitution cipher";
const string encodedInput = "Guvf vf n fhofgvghgvba pvcure";
string repoPath = InitNewRepository();
Action<Stream, Stream> cleanCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
var filter = new FakeFilter(FilterName, attributes, cleanCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
using (var repo = CreateTestRepository(repoPath))
{
FileInfo expectedFile = StageNewFile(repo, decodedInput);
var commit = repo.Commit("Clean that file", Constants.Signature, Constants.Signature);
var blob = (Blob)commit.Tree[expectedFile.Name].Target;
var textDetected = blob.GetContentText();
Assert.Equal(encodedInput, textDetected);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void WhenStagingFileApplyIsCalledWithCleanForCorrectPath()
{
string repoPath = InitNewRepository();
bool called = false;
Action<Stream, Stream> clean = (reader, writer) =>
{
called = true;
reader.CopyTo(writer);
};
var filter = new FakeFilter(FilterName, attributes, clean);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
using (var repo = CreateTestRepository(repoPath))
{
StageNewFile(repo);
Assert.True(called);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void InitCallbackMadeWhenUsingTheFilter()
{
bool called = false;
Action initializeCallback = () =>
{
called = true;
};
var filter = new FakeFilter(FilterName,
attributes,
successCallback,
successCallback,
initializeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
Assert.False(called);
string repoPath = InitNewRepository();
using (var repo = CreateTestRepository(repoPath))
{
StageNewFile(repo);
Assert.True(called);
}
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public void InitCallbackNotMadeWhenFilterNeverUsed()
{
bool called = false;
Action initializeCallback = () =>
{
called = true;
};
var filter = new FakeFilter(FilterName,
attributes,
successCallback,
successCallback,
initializeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
Assert.False(called);
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public static FakeFilter OtherFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{B67473BF-9FA1-4674-831E-CB28F72D4791}";
f.Name = SR.GetString("Resources_OtherFiles");
f.Filter = "*";
f.SCCFiles = false;
return f;
}
public void WhenCheckingOutAFileFileSmudgeWritesCorrectFileToWorkingDirectory()
{
const string decodedInput = "This is a substitution cipher";
const string encodedInput = "Guvf vf n fhofgvghgvba pvcure";
const string branchName = "branch";
string repoPath = InitNewRepository();
Action<Stream, Stream> smudgeCallback = SubstitutionCipherFilter.RotateByThirteenPlaces;
var filter = new FakeFilter(FilterName, attributes, null, smudgeCallback);
var registration = GlobalSettings.RegisterFilter(filter);
try
{
FileInfo expectedFile = CheckoutFileForSmudge(repoPath, branchName, encodedInput);
string combine = Path.Combine(repoPath, "..", expectedFile.Name);
string readAllText = File.ReadAllText(combine);
Assert.Equal(decodedInput, readAllText);
}
finally
{
GlobalSettings.DeregisterFilter(registration);
}
}
public static FakeFilter TranslationFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{639EADAA-A684-42e4-A9AD-28FC9BCB8F7C}";
f.Name = SR.GetString("Resources_TranslationFiles");
f.Filter = "ts";
f.ParseFiles = false;
return f;
}
public static FakeFilter ResourceFiles()
{
FakeFilter f = new FakeFilter();
f.UniqueIdentifier = "{D9D6E242-F8AF-46E4-B9FD-80ECBC20BA3E}";
f.Name = SR.GetString("Resources_ResourceFiles");
f.ParseFiles = false;
f.Filter = "qrc;*";
return f;
}
