public void Setup()
{
settings.EncodingSettings.OutputFile = Path.GetTempFileName();
App.Current.DatabaseManager = new LocalDatabaseManager();
project = Utils.CreateProject();
projectVM = new LMProjectVM {
Model = project
};
LMProjectAnalysisVM viewModel = new LMProjectAnalysisVM();
viewModel.VideoPlayer = videoPlayerVM;
viewModel.Project = projectVM;
projectsManager = new ProjectAnalysisController();
projectsManager.SetViewModel(viewModel);
projectsManager.Start();
KeyContext context = new KeyContext();
foreach (KeyAction action in projectsManager.GetDefaultKeyActions())
{
context.AddAction(action);
}
App.Current.KeyContextManager.NewKeyContexts(new List <KeyContext> {
context
});
}
public void ViewModelFactoryService_CreateLMProjectVM()
{
var model = new LMProject();
var vm = factoryService.CreateViewModel <LMProjectVM, LMProject> (model);
Assert.IsTrue(vm is LMProjectVM);
}
bool SaveProject()
{
LMProject project = Project.Model;
if (project == null)
{
return(false);
}
Log.Debug(String.Format("Saving project {0} type: {1}", project.ID, project.ProjectType));
if (Project.ProjectType == ProjectType.FileProject)
{
return(UpdateProject(project));
}
else if (Project.ProjectType == ProjectType.FakeCaptureProject)
{
project.Periods.Reset(Capturer.Periods);
return(UpdateProject(project));
}
else if (Project.ProjectType == ProjectType.CaptureProject ||
Project.ProjectType == ProjectType.URICaptureProject)
{
return(SaveCaptureProject(project));
}
else
{
return(false);
}
}
public void TestClearAll()
{
LMProject p = Utils.CreateProject();
try {
EventsFilter filter = new EventsFilter(p);
filter.FilterPlayer(p.LocalTeamTemplate.List [0], true);
Assert.AreEqual(1, filter.VisiblePlays.Count);
Assert.AreEqual(1, filter.VisiblePlayers.Count);
filter.ClearAll();
Assert.AreEqual(3, filter.VisiblePlays.Count);
Assert.AreEqual(10, filter.VisiblePlayers.Count);
filter.FilterEventType(p.EventTypes [0], true);
Assert.AreEqual(1, filter.VisiblePlays.Count);
Assert.AreEqual(1, filter.VisibleEventTypes.Count);
filter.ClearAll();
Assert.AreEqual(3, filter.VisiblePlays.Count);
Assert.AreEqual(15, filter.VisibleEventTypes.Count);
filter.FilterEventTag(p.EventTypes [0], (p.EventTypes [0] as AnalysisEventType).Tags [0], true);
Assert.AreEqual(0, filter.VisiblePlays.Count);
Assert.AreEqual(1, filter.VisibleEventTypes.Count);
filter.ClearAll();
Assert.AreEqual(3, filter.VisiblePlays.Count);
Assert.AreEqual(15, filter.VisibleEventTypes.Count);
} finally {
Utils.DeleteProject(p);
}
}
public void TestFilterPlayersDuplicated()
{
LMProject p = Utils.CreateProject();
p.VisitorTeamTemplate = p.LocalTeamTemplate;
try {
EventsFilter filter = new EventsFilter(p);
Assert.AreEqual(5, filter.VisiblePlayers.Count);
Assert.AreEqual(3, filter.VisiblePlays.Count);
foreach (LMPlayer player in p.LocalTeamTemplate.List)
{
filter.FilterPlayer(player, true);
}
Assert.AreEqual(5, filter.VisiblePlayers.Count);
Assert.AreEqual(3, filter.VisiblePlays.Count);
foreach (LMPlayer player in p.VisitorTeamTemplate.List)
{
filter.FilterPlayer(player, true);
}
Assert.AreEqual(5, filter.VisiblePlayers.Count);
Assert.AreEqual(3, filter.VisiblePlays.Count);
filter.ClearAll();
Assert.AreEqual(5, filter.VisiblePlayers.Count);
Assert.AreEqual(3, filter.VisiblePlays.Count);
} finally {
Utils.DeleteProject(p);
}
}
public void TestFilterPlayers()
{
LMProject p = Utils.CreateProject();
try {
EventsFilter filter = new EventsFilter(p);
Assert.AreEqual(10, filter.VisiblePlayers.Count);
Assert.AreEqual(3, filter.VisiblePlays.Count);
filter.FilterPlayer(p.LocalTeamTemplate.List [4], true);
Assert.AreEqual(0, filter.VisiblePlays.Count);
Assert.AreEqual(1, filter.VisiblePlayers.Count);
filter.FilterPlayer(p.LocalTeamTemplate.List [0], true);
Assert.AreEqual(1, filter.VisiblePlays.Count);
Assert.AreEqual(2, filter.VisiblePlayers.Count);
filter.FilterPlayer(p.LocalTeamTemplate.List [0], true);
Assert.AreEqual(1, filter.VisiblePlays.Count);
Assert.AreEqual(2, filter.VisiblePlayers.Count);
filter.FilterPlayer(p.LocalTeamTemplate.List [0], false);
Assert.AreEqual(0, filter.VisiblePlays.Count);
Assert.AreEqual(1, filter.VisiblePlayers.Count);
filter.FilterPlayer(p.LocalTeamTemplate.List [4], false);
Assert.AreEqual(10, filter.VisiblePlayers.Count);
Assert.AreEqual(3, filter.VisiblePlays.Count);
} finally {
Utils.DeleteProject(p);
}
}
void HandleProjectSelected(LMProject project)
{
project.ProjectType = ProjectType.FileProject;
LMStateHelper.OpenProject(new LMProjectVM {
Model = project
});
}
void HandleFileChangedEvent(FileChangeType eventType, string path)
{
// Event from the monitor usually comes from non-UI threads.
App.Current.GUIToolkit.Invoke((s, e) => {
if (eventType == FileChangeType.Created)
{
string ext = Path.GetExtension(path);
try {
if (ImportTeams && ext == Constants.TEAMS_TEMPLATE_EXT)
{
LMTeam team = App.Current.DependencyRegistry.
Retrieve <IFileStorage> (InstanceType.Default, null).RetrieveFrom <LMTeam> (path);
App.Current.TeamTemplatesProvider.Add(team);
File.Delete(path);
}
else if (ImportDashboards && ext == Constants.CAT_TEMPLATE_EXT)
{
Dashboard team = App.Current.DependencyRegistry.
Retrieve <IFileStorage> (InstanceType.Default, null).RetrieveFrom <Dashboard> (path);
App.Current.CategoriesTemplatesProvider.Add(team as LMDashboard);
File.Delete(path);
}
else if (ImportProjects && ext == Constants.PROJECT_EXT)
{
LMProject project = App.Current.DependencyRegistry.
Retrieve <IFileStorage> (InstanceType.Default, null).RetrieveFrom <LMProject> (path);
App.Current.DatabaseManager.ActiveDB.Store <LMProject> (project, true);
File.Delete(path);
}
} catch (Exception ex) {
Log.Exception(ex);
}
}
});
}
async Task <bool> CaptureFinished(bool cancel, bool delete, bool reopen)
{
LMProject project = Project.Model;
ProjectType type = Project.ProjectType;
if (delete)
{
if (type != ProjectType.FakeCaptureProject)
{
try {
File.Delete(Capturer.CaptureSettings.EncodingSettings.OutputFile);
} catch (Exception ex1) {
Log.Exception(ex1);
}
}
try {
App.Current.DatabaseManager.ActiveDB.Delete <LMProject> (project);
} catch (StorageException ex) {
Log.Exception(ex);
App.Current.Dialogs.ErrorMessage(ex.Message);
}
}
// if it comes from a cancel operation the close have been handled
bool closeOk = await CloseOpenedProject(!cancel, !reopen);
if (closeOk && reopen && !cancel && type != ProjectType.FakeCaptureProject)
{
Project.ProjectType = ProjectType.FileProject;
Project.CloseHandled = true; // the reopen comes from a close operation avoid asking again
LMStateHelper.OpenProject(Project);
}
return(false);
}
public EditCategoryDialog(LMProject project, DashboardButton tagger, Window parent)
{
TransientFor = parent;
this.Build();
timenodeproperties2.Tagger = tagger;
timenodeproperties2.Dashboard = project.Dashboard;
}
LMProject CreateProject()
{
var project = new LMProject {
Description = new ProjectDescription()
};
project.LocalTeamTemplate = (LMTeam)App.Current.TeamTemplatesProvider.Templates.FirstOrDefault(t => t.Name == "spain");
Assert.IsNotNull(project.LocalTeamTemplate);
project.VisitorTeamTemplate = (LMTeam)App.Current.TeamTemplatesProvider.Templates.FirstOrDefault(t => t.Name == "france");
Assert.IsNotNull(project.VisitorTeamTemplate);
project.Dashboard = App.Current.CategoriesTemplatesProvider.Templates.FirstOrDefault(t => t.Name == "basket") as LMDashboard;
Assert.IsNotNull(project.Dashboard);
project.Description.Competition = "Liga";
project.Description.MatchDate = DateTime.UtcNow;
project.Description.Description = "Created by LongoMatch";
project.Description.Season = "2015-2016";
project.Description.LocalName = project.LocalTeamTemplate.TeamName;
project.Description.VisitorName = project.VisitorTeamTemplate.TeamName;
project.Description.FileSet = new MediaFileSet();
project.Description.FileSet.Add(new MediaFile {
FilePath = "Test.mp4",
Duration = new Time {
TotalSeconds = 60000
}
});
project.UpdateEventTypesAndTimers();
return(project);
}
private TreeStore GetModel(LMProject project)
{
Gtk.TreeIter iter;
Gtk.TreeStore dataFileListStore = new Gtk.TreeStore(typeof(object));
itersDic.Clear();
foreach (EventType evType in project.EventTypes)
{
iter = dataFileListStore.AppendValues(evType);
itersDic.Add(evType, iter);
}
var queryPlaysByCategory = project.EventsGroupedByEventType;
foreach (var playsGroup in queryPlaysByCategory)
{
EventType cat = playsGroup.Key;
if (!itersDic.ContainsKey(cat))
{
continue;
}
foreach (TimelineEvent play in playsGroup)
{
dataFileListStore.AppendValues(itersDic [cat], play);
}
}
return(dataFileListStore);
}
public void TestDeleteProjectItems()
{
LMProject p = new LMProject();
p.Dashboard = LMDashboard.DefaultTemplate(10);
p.UpdateEventTypesAndTimers();
p.LocalTeamTemplate = LMTeam.DefaultTemplate(10);
for (int i = 0; i < 10; i++)
{
LMTimelineEvent evt = new LMTimelineEvent {
EventType = p.EventTypes [i],
Start = new Time(1000),
Stop = new Time(2000),
};
p.Timeline.Add(evt);
}
storage.Store(p);
p = storage.Retrieve <LMProject> (p.ID);
// Removing this object should not remove the EvenType from the database, which might be referenced by
// LMTimelineEvent's in the timeline
EventType evtType = (p.Dashboard.List [0] as AnalysisEventButton).EventType;
p.Dashboard.List.Remove(p.Dashboard.List [0]);
storage.Store(p);
Assert.DoesNotThrow(() => storage.Retrieve <LMProject> (p.ID));
// Delete an event with a LMPlayer, a Team and an EventType, it should delete only the timeline event
p.Timeline [0].Teams.Add(p.LocalTeamTemplate);
p.Timeline [0].Players.Add(p.LocalTeamTemplate.List [0]);
p.Timeline.Remove(p.Timeline [0]);
Assert.DoesNotThrow(() => storage.Retrieve <LMProject> (p.ID));
}
public void TestListProjects()
{
LMProject p = Utils.CreateProject();
try {
p.Description.Group = "GRP";
p.Description.Competition = "COMP";
storage.Store(p);
List <LMProject> projects = storage.RetrieveAll <LMProject> ().ToList();
Assert.AreEqual(1, projects.Count);
Assert.AreEqual(p.Timeline.Count, projects [0].Timeline.Count);
Assert.AreEqual("GRP", p.Description.Group);
Assert.AreEqual("COMP", p.Description.Competition);
Assert.IsTrue(projects.All(i => i.DocumentID != null));
Assert.AreEqual(1, storage.Retrieve <LMProject> (null).Count());
var filter = new QueryFilter();
filter.Add("Competition", "COMP");
Assert.AreEqual(1, storage.Retrieve <LMProject> (filter).Count());
} finally {
Utils.DeleteProject(p);
}
}
public void TestProject()
{
LMProject p = new LMProject();
p.Dashboard = LMDashboard.DefaultTemplate(10);
p.UpdateEventTypesAndTimers();
p.LocalTeamTemplate = LMTeam.DefaultTemplate(10);
p.VisitorTeamTemplate = LMTeam.DefaultTemplate(12);
MediaFile mf = new MediaFile("path", 34000, 25, true, true, "mp4", "h264",
"aac", 320, 240, 1.3, null, "Test asset");
var pd = new ProjectDescription();
pd.FileSet = new MediaFileSet();
pd.FileSet.Add(mf);
p.Description = pd;
p.AddEvent(new LMTimelineEvent());
storage.Store <LMProject> (p);
Assert.AreEqual(45, db.DocumentCount);
p = storage.RetrieveAll <LMProject> ().First();
Assert.IsNotNull(p.DocumentID);
p.Load();
Assert.IsTrue(Object.ReferenceEquals(p.Description.FileSet, p.Timeline [0].FileSet));
storage.Store(p);
Assert.AreEqual(45, db.DocumentCount);
storage.Delete(p);
Assert.AreEqual(1, db.DocumentCount);
}
void FillTags(LMProject project, LMTimelineEvent evt)
{
Dictionary <string, List <Tag> > tagsByGroup;
SizeGroup sgroup = new SizeGroup(SizeGroupMode.Horizontal);
if (evt.EventType is AnalysisEventType)
{
tagsByGroup = (evt.EventType as AnalysisEventType).TagsByGroup;
}
else
{
tagsByGroup = new Dictionary <string, List <Tag> > ();
}
tagsvbox.PackStart(new HSeparator());
foreach (var kv in project.Dashboard.CommonTagsByGroup)
{
AddTagsGroup(evt, kv.Key, kv.Value, sgroup);
}
foreach (var kv in tagsByGroup)
{
AddTagsGroup(evt, kv.Key, kv.Value, sgroup);
}
tagsvbox.ShowAll();
}
public void OneTimeSetUp()
{
SetupClass.SetUp();
futureProject = Utils.CreateProject();
futureProject.CreationDate = DateTime.Parse("12/12/9999");
pastProject = Utils.CreateProject();
pastProject.CreationDate = DateTime.Parse("12/12/2000");
nowProject = Utils.CreateProject();
nowProject.CreationDate = DateTime.Now;
projectList = new List <LMProject> {
futureProject,
pastProject,
nowProject
};
notLimitedLimitation = new CountLicenseLimitation {
Count = 0,
Enabled = false
};
limitedLimitation = new CountLicenseLimitation {
Count = 0,
Enabled = true,
Maximum = 1
};
storageMock = new Mock <IStorage> ();
App.Current.DatabaseManager = Mock.Of <IStorageManager> ();
App.Current.DatabaseManager.ActiveDB = storageMock.Object;
}
void LoadIcons()
{
LMProject project = ViewModel.Model;
notebookHelper = new Helpers.IconNotebookHelper(playsnotebook);
notebookHelper.SetTabIcon(eventsScrolledWindow, "vas-category", "vas-category",
Catalog.GetString("Both Teams"));
if (project.LocalTeamTemplate.Shield != null)
{
var localIcon = project.LocalTeamTemplate.Shield;
notebookHelper.SetTabIcon(homescrolledwindow, localIcon, localIcon, project.LocalTeamTemplate.Name);
}
else
{
notebookHelper.SetTabIcon(homescrolledwindow, "vas-default-shield", "vas-default-shield",
project.LocalTeamTemplate.Name);
}
if (project.VisitorTeamTemplate.Shield != null)
{
var visitorIcon = project.VisitorTeamTemplate.Shield;
notebookHelper.SetTabIcon(awayscrolledwindow, visitorIcon, visitorIcon, project.VisitorTeamTemplate.Name);
}
else
{
notebookHelper.SetTabIcon(awayscrolledwindow, "vas-default-shield", "vas-default-shield",
project.VisitorTeamTemplate.Name);
}
notebookHelper.UpdateTabs();
}
public void TestImport()
{
// Arrange
string path = Path.GetTempFileName();
string videopath = Path.GetTempFileName();
string originalPath = Path.Combine("non-existing-path", Path.GetFileName(videopath));
mockDialog.Setup(g => g.OpenFile(It.IsAny <string> (), It.IsAny <string> (), It.IsAny <string> (), It.IsAny <string> (), It.IsAny <string[]> ())).Returns(path);
mockDialog.Setup(g => g.BusyDialog(It.IsAny <string> (), It.IsAny <object> ())).Returns(new DummyBusyDialog());
App.Current.GUIToolkit = mockGUI.Object;
App.Current.Dialogs = mockDialog.Object;
LMProject p = Utils.CreateProject();
p.FileSet.First().FilePath = originalPath;
Assert.IsFalse(p.FileSet.CheckFiles());
Project.Export(p, path);
try {
// Act
Project imported = importer.ImportProject();
// Assert
Assert.AreEqual(p, imported);
Assert.AreEqual(videopath, imported.FileSet.First().FilePath);
Assert.IsTrue(imported.FileSet.CheckFiles());
} finally {
File.Delete(path);
File.Delete(videopath);
}
}
LMProject CreateProject(bool fill = true)
{
LMProject p = new LMProject();
p.Dashboard = LMDashboard.DefaultTemplate(10);
p.UpdateEventTypesAndTimers();
p.LocalTeamTemplate = LMTeam.DefaultTemplate(10);
p.VisitorTeamTemplate = LMTeam.DefaultTemplate(12);
MediaFile mf = new MediaFile("path", 34000, 25, true, true, "mp4", "h264",
"aac", 320, 240, 1.3, null, "Test asset");
var pd = new ProjectDescription();
pd.FileSet = new MediaFileSet();
pd.FileSet.Add(mf);
p.Description = pd;
if (fill)
{
p.AddEvent(p.EventTypes [0], new Time(1000), new Time(2000), null, null);
p.AddEvent(p.EventTypes [0], new Time(1000), new Time(2000), null, null);
p.AddEvent(p.EventTypes [1], new Time(1000), new Time(2000), null, null);
p.AddEvent(p.EventTypes [2], new Time(1000), new Time(2000), null, null);
p.AddEvent(p.EventTypes [2], new Time(1000), new Time(2000), null, null);
p.AddEvent(p.EventTypes [2], new Time(1000), new Time(2000), null, null);
p.AddEvent(p.EventTypes [6], new Time(1000), new Time(2000), null, null);
}
return(p);
}
public void TestMigration()
{
string dir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(dir);
var assembly = Assembly.GetExecutingAssembly();
using (Stream fs = assembly.GetManifestResourceStream("longomatch.tar.gz")) {
using (Stream gzipStream = new GZipInputStream(fs)) {
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream)) {
tarArchive.ExtractContents(dir);
}
}
}
CouchbaseStorageLongoMatch storage = new CouchbaseStorageLongoMatch(dir, "longomatch");
Assert.AreEqual(2, storage.RetrieveAll <Team> ().Count());
Assert.AreEqual(1, storage.RetrieveAll <Dashboard> ().Count());
Assert.AreEqual(1, storage.RetrieveAll <LMProject> ().Count());
Team team = storage.RetrieveAll <Team> ().First();
Assert.DoesNotThrow(team.Load);
Dashboard dashboard = storage.RetrieveAll <Dashboard> ().First();
Assert.DoesNotThrow(dashboard.Load);
LMProject project = storage.RetrieveAll <LMProject> ().First();
Assert.DoesNotThrow(project.Load);
}
public void LoadState_ViewModelFromPropDisposed_AssignOnlyModel()
{
// Arrange
FakeLiveProjectAnalysisState state = new FakeLiveProjectAnalysisState();
LMProject project = Utils.CreateProject();
LMProjectVM projectVM = new LMProjectVM {
Model = project
};
LMProjectAnalysisVM analysisVM = new LMProjectAnalysisVM {
Project = projectVM
};
var panel = new Mock <Utils.IDummyCapturerPanel> ();
panel.Setup(p => p.Capturer).Returns(capturerMock.Object);
state.Panel = panel.Object;
// Act
state.LoadState(analysisVM);
// Assert
capturerMock.Verify(c => c.Run(It.IsAny <CaptureSettings> (), It.IsAny <MediaFile> ()), Times.Once);
Assert.AreNotEqual(projectVM, state.ViewModel.Project);
Assert.AreEqual(project, state.ViewModel.Project.Model);
}
public EditCategoryDialog(LMProject project, EventType eventType, Window parent)
{
TransientFor = parent;
this.Build();
timenodeproperties2.EventType = eventType;
timenodeproperties2.Dashboard = project.Dashboard;
}
public async Task ExportProject_NoLimitation_ExportFinishedOk()
{
// Arrange
LMProject p = null;
string tmp = Path.GetTempFileName();
if (File.Exists(tmp))
{
File.Delete(tmp);
}
try {
p = Utils.CreateProject(false);
DummyLongoMAtchExporterExporter exporter = new DummyLongoMAtchExporterExporter();
// Act
await exporter.Export(p, tmp);
// Assert
Assert.IsTrue(File.Exists(tmp));
Assert.IsTrue(exporter.ExportDone);
} finally {
Utils.DeleteProject(p);
if (File.Exists(tmp))
{
File.Delete(tmp);
}
}
}
void UpdateSelection(TreeIter iter, bool active)
{
LMProject project = store.GetValue(iter, COL_PROJECT) as LMProject;
bool wasActive = (bool)store.GetValue(iter, COL_ACTIVE);
if (wasActive != active)
{
store.SetValue(iter, COL_ACTIVE, active);
if (active)
{
if (!selectedProjects.Contains(project))
{
selectedProjects.Add(project);
}
}
else
{
selectedProjects.Remove(project);
}
}
if (!swallowSignals && ProjectsSelected != null)
{
ProjectsSelected(selectedProjects);
}
}
public void LoadStats(ProjectStats pstats, LMProject project)
{
categoryviewer1.HomeName = project.LocalTeamTemplate.TeamName;
categoryviewer1.AwayName = project.VisitorTeamTemplate.TeamName;
categoryviewer1.LoadBackgrounds(project);
this.pstats = pstats;
ReloadStats();
}
public EventTypeStats(LMProject project, EventsFilter filter, EventType evType)
{
Name = evType.Name;
events = new List <LMTimelineEvent> ();
this.project = project;
this.filter = filter;
this.eventType = evType;
}
public void ShowStats(LMProject project)
{
StatsDialog statsui = new StatsDialog();
statsui.LoadStats(project);
statsui.Run();
statsui.Destroy();
}
public void TestCaptureFinished()
{
List <string> transitions = new List <string> ();
App.Current.EventsBroker.Subscribe <NavigationEvent> ((obj) => {
transitions.Add(obj.Name);
});
projectsManager.Capturer = capturerBinMock.Object;
projectsManager.ViewModel.Project.Model = project;
projectsManager.ViewModel.CaptureSettings = settings;
projectsManager.ViewModel.Project.ProjectType = ProjectType.CaptureProject;
App.Current.EventsBroker.Publish <CaptureFinishedEvent> (
new CaptureFinishedEvent {
Cancel = true,
Reopen = true
}
);
Assert.IsTrue(projectsManager.ViewModel.Project.CloseHandled);
Assert.AreEqual(0, App.Current.DatabaseManager.ActiveDB.Count <LMProject> ());
Assert.AreEqual(project, projectsManager.Project.Model); // SP-Remark: check that project is null has no sense here
capturerBinMock.Verify(c => c.Close(), Times.Once());
capturerBinMock.ResetCalls();
Assert.AreEqual("Home", App.Current.StateController.Current); // replaced previous line for this one
gtkMock.ResetCalls();
Utils.DeleteProject(project);
project = Utils.CreateProject();
settings.EncodingSettings.OutputFile = project.Description.FileSet.FirstOrDefault().FilePath;
projectsManager.Capturer = capturerBinMock.Object;
projectsManager.ViewModel.Project.Model = project;
projectsManager.ViewModel.CaptureSettings = settings;
projectsManager.ViewModel.Project.ProjectType = ProjectType.CaptureProject;
App.Current.EventsBroker.Publish <CaptureFinishedEvent> (
new CaptureFinishedEvent {
Cancel = false,
Reopen = true
}
);
capturerBinMock.Verify(c => c.Close(), Times.Once());
/* We are not prompted to quit the capture */
gtkMock.Verify(g => g.EndCapture(true), Times.Never());
gtkMock.Verify(g => g.RemuxFile(It.IsAny <string> (),
settings.EncodingSettings.OutputFile, VideoMuxerType.Mp4));
Assert.AreEqual("Home", App.Current.StateController.Current);
Assert.AreEqual(1, App.Current.DatabaseManager.ActiveDB.Count <LMProject> ());
Assert.AreEqual(project, projectsManager.Project.Model);
/*Assert.AreEqual (ProjectType.FileProject, projectsManager.OpenedProjectType);
* // Make sure the project is not cleared.
* Assert.IsNotEmpty (projectsManager.Project.Dashboard.List);
* Assert.IsNotEmpty (projectsManager.Project.LocalTeamTemplate.List);
* Assert.IsNotEmpty (projectsManager.Project.VisitorTeamTemplate.List);*/
}
public void SetUp()
{
model = Utils.CreateProject(true);
viewModel = new LMProjectVM {
Model = model
};
model.IsChanged = false;
viewModel.IsChanged = false;
}
