public void TestAutoRoll()
{
var handler =
CommandGenerator.CreateAutoCommandHandler <HyperDeckSettingsSetCommand, HyperDeckSettingsGetCommand>(
"AutoRoll");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.HyperDecks, helper =>
{
foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper))
{
for (int i = 0; i < 5; i++)
{
deck.GetId(out long id);
AtemState stateBefore = helper.Helper.BuildLibState();
HyperdeckState hyperdeckState = stateBefore.Hyperdecks[(int)id];
hyperdeckState.Settings.AutoRoll = !hyperdeckState.Settings.AutoRoll;
helper.SendAndWaitForChange(stateBefore,
() => { deck.SetAutoRollOnTake(hyperdeckState.Settings.AutoRoll ? 1 : 0); });
}
}
});
}
/// <see cref="NI.Data.IDalc.Delete(NI.Data.Query)"/>
public virtual int Delete(Query query)
{
using (var deleteCmd = CommandGenerator.ComposeDelete(query)) {
return(ExecuteInternal(deleteCmd, query.Table.Name, StatementType.Delete));
}
}
// GetWorkBufferSize(nn::audio::detail::AudioRendererParameterInternal) -> u64
public ResultCode GetAudioRendererWorkBufferSize(ServiceCtx context)
{
AudioRendererParameter parameters = GetAudioRendererParameter(context);
if (AudioRendererCommon.CheckValidRevision(parameters))
{
BehaviorInfo behaviorInfo = new BehaviorInfo();
behaviorInfo.SetUserLibRevision(parameters.Revision);
long size;
int totalMixCount = parameters.SubMixCount + 1;
size = BitUtils.AlignUp(parameters.MixBufferCount * 4, AudioRendererConsts.BufferAlignment) +
parameters.SubMixCount * 0x400 +
totalMixCount * 0x940 +
parameters.VoiceCount * 0x3F0 +
BitUtils.AlignUp(totalMixCount * 8, 16) +
BitUtils.AlignUp(parameters.VoiceCount * 8, 16) +
BitUtils.AlignUp(((parameters.SinkCount + parameters.SubMixCount) * 0x3C0 + parameters.SampleCount * 4) *
(parameters.MixBufferCount + 6), AudioRendererConsts.BufferAlignment) +
(parameters.SinkCount + parameters.SubMixCount) * 0x2C0 +
(parameters.EffectCount + parameters.VoiceCount * 4) * 0x30 +
0x50;
if (behaviorInfo.IsSplitterSupported())
{
size += BitUtils.AlignUp(NodeStates.GetWorkBufferSize(totalMixCount) + EdgeMatrix.GetWorkBufferSize(totalMixCount), 16);
}
size = parameters.SinkCount * 0x170 +
(parameters.SinkCount + parameters.SubMixCount) * 0x280 +
parameters.EffectCount * 0x4C0 +
((size + SplitterContext.CalcWorkBufferSize(behaviorInfo, parameters) + 0x30 * parameters.EffectCount + (4 * parameters.VoiceCount) + 0x8F) & ~0x3FL) +
((parameters.VoiceCount << 8) | 0x40);
if (parameters.PerformanceManagerCount >= 1)
{
size += (PerformanceManager.GetRequiredBufferSizeForPerformanceMetricsPerFrame(behaviorInfo, parameters) *
(parameters.PerformanceManagerCount + 1) + 0xFF) & ~0x3FL;
}
if (behaviorInfo.IsVariadicCommandBufferSizeSupported())
{
size += CommandGenerator.CalculateCommandBufferSize(parameters) + 0x7E;
}
else
{
size += 0x1807E;
}
size = BitUtils.AlignUp(size, 0x1000);
context.ResponseData.Write(size);
Logger.PrintDebug(LogClass.ServiceAudio, $"WorkBufferSize is 0x{size:x16}.");
return(ResultCode.Success);
}
else
{
context.ResponseData.Write(0L);
Logger.PrintWarning(LogClass.ServiceAudio, $"Library Revision REV{AudioRendererCommon.GetRevisionVersion(parameters.Revision)} is not supported!");
return(ResultCode.UnsupportedRevision);
}
}
public void PowerOff() => _socketService.SendPacket(CommandGenerator.PowerCommandGenerator(PowerCommandEnum.Standby));
public void TestCurrentClipTime()
{
var handler =
CommandGenerator.CreateAutoCommandHandler <HyperDeckPlayerSetCommand, HyperDeckPlayerGetCommand>(
"ClipTime");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.HyperDecks, helper =>
{
ImmutableList <ICommand> allCommands = helper.Server.GetParsedDataDump();
List <HyperDeckSettingsGetCommand> settingsCommands = allCommands.OfType <HyperDeckSettingsGetCommand>().ToList();
foreach (IBMDSwitcherHyperDeck deck in GetHyperDecks(helper))
{
deck.GetId(out long id);
HyperDeckSettingsGetCommand cmd = settingsCommands.Single(c => c.Id == id);
// Force it to be connected
AtemState stateBefore = helper.Helper.BuildLibState();
cmd.Status = HyperDeckConnectionStatus.Connected;
stateBefore.Hyperdecks[(int)id].Settings.Status = HyperDeckConnectionStatus.Connected;
stateBefore.Hyperdecks[(int)id].Player.State = HyperDeckPlayerState.Idle;
helper.SendFromServerAndWaitForChange(stateBefore, cmd);
// Define a clip
stateBefore.Hyperdecks[(int)id].Clips =
UpdaterUtil.CreateList(1, i => new HyperdeckState.ClipState());
helper.SendFromServerAndWaitForChange(stateBefore, new HyperDeckClipCountCommand
{
Id = (uint)id,
ClipCount = 1,
});
var clipCmd = new HyperDeckClipInfoCommand
{
HyperdeckId = (uint)id,
ClipId = 0,
Name = "something 123",
Duration = new HyperDeckTime {
Hour = 24
},
TimelineStart = new HyperDeckTime(),
TimelineEnd = new HyperDeckTime {
Hour = 24
},
};
AtemStateBuilder.Update(stateBefore, clipCmd);
helper.SendFromServerAndWaitForChange(stateBefore, clipCmd);
stateBefore = helper.Helper.BuildLibState();
// Set the clip to be playing
HyperDeckStorageGetCommand playCmd = new HyperDeckStorageGetCommand
{
Id = (uint)id,
ActiveStorageMedia = 0,
CurrentClipId = 0,
FrameRate = 50000,
TimeScale = 1000,
RemainingRecordTime = new HyperDeckTime()
};
AtemStateBuilder.Update(stateBefore, playCmd);
helper.SendFromServerAndWaitForChange(stateBefore, playCmd);
stateBefore = helper.Helper.BuildLibState();
HyperdeckState deckState = stateBefore.Hyperdecks[(int)id];
// Now try the stuff
for (int i = 0; i < 5; i++)
{
uint hours = (uint)Randomiser.RangeInt(1, 20);
uint minutes = (uint)Randomiser.RangeInt(1, 59);
uint seconds = (uint)Randomiser.RangeInt(1, 59);
uint frames = (uint)Randomiser.RangeInt(1, 20);
deckState.Player.TimelineTime = new HyperDeckTime();
deckState.Player.ClipTime = new HyperDeckTime
{
Hour = hours, Minute = minutes, Second = seconds, Frame = frames
};
helper.SendAndWaitForChange(stateBefore,
() =>
{
deck.SetCurrentClipTime((ushort)hours, (byte)minutes, (byte)seconds, (byte)frames);
});
}
}
});
}
public void GenerateCommandList_withAFileInFolderInTheLocalRootThatIsOlderThanTheSameInTheRemoteFolder_shouldGenerateADeleteCommandAndAnUpdateCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif = 2015-1-1-0-0-0 - Size = 1024
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// Then the generated command list should be:
// Delete \Folder1\File1.jpeg
// Upload \Folder1\File1.jpeg
const string fileName = "File1.jpeg";
const long size = 1024;
const string folderName = "Folder1";
var localLastModifiedDate = new DateTime(2015, 1, 1, 0, 0, 0);
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localFile1 = new FileItem(ItemType.File, @"\" + folderName + @"\" + fileName, size, localLastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFolder1,
localFile1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
// File1
var mockMegaNzNodeForRemoteFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteLastModifiedDate = localLastModifiedDate.AddYears(1);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForRemoteFile1.Object, fileName, ItemType.File, @"\" + folderName + @"\" + fileName, size, remoteLastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(2);
commandList[0].Should().BeOfType <DeleteFileCommand>();
var deleteFileCommand = (DeleteFileCommand)commandList[0];
deleteFileCommand.PathToDelete.Should().Be(@"\Folder1\File1.jpeg");
deleteFileCommand.LastModifiedDate.Should().Be(remoteLastModifiedDate);
commandList[1].Should().BeOfType <UploadFileCommand>();
var uploadFileCommand = (UploadFileCommand)commandList[1];
uploadFileCommand.SourcePath.Should().Be(localBasePath + folderName + @"\" + fileName);
uploadFileCommand.DestinationPath.Should().Be(@"\" + folderName + @"\"); // Because we need the backslash at the end of the path for a folder
uploadFileCommand.LastModifiedDate.Should().Be(localLastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForRemoteFolder1.VerifyAll();
mockMegaNzNodeForRemoteFile1.VerifyAll();
}
public void GenerateCommandList_withAFileInFolderInTheRemoteRootThatIsNotInTheLocalFolder_shouldGenerateADeleteCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif 2016-1-1-0-0-0
//
// Then the generated command list should be:
// - Delete \Folder1\File1.jpeg
// Local file structure
const string folderName = "Folder1";
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localItems = new List <FileItem> {
localRoot,
localFolder1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
// File1
var mockMegaNzNodeForRemoteFile1 = new Mock <INode>(MockBehavior.Strict);
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForRemoteFile1.Object, "File1.jpeg", ItemType.File, @"\" + folderName + @"\File1.jpeg", 1024, lastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var generator = new CommandGenerator(localBasePath);
var commandList = generator.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(1);
commandList[0].Should().BeOfType <DeleteFileCommand>();
var deleteCommand = (DeleteFileCommand)commandList[0];
deleteCommand.PathToDelete.Should().Be(@"\Folder1\File1.jpeg");
deleteCommand.LastModifiedDate.Should().Be(lastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForRemoteFolder1.VerifyAll();
mockMegaNzNodeForRemoteFile1.VerifyAll();
}
public void GenerateCommandList_withAFileInTheLocalRootThatHasDifferentSizeThanTheSameInTheRemoteRoot_shouldGenerateADeleteCommandAndAnUpdateCommand()
{
// Given the following local file structure:
// root
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 2048
//
// And given the following remote file structure:
// root
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// Then the generated command list should be:
// Delete \File1.jpeg
// Upload \File1.jpeg
const string fileName = "File1.jpeg";
const long size = 1024;
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFile1 = new FileItem(ItemType.File, @"\" + fileName, size, lastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFile1
};
// Remote file structure
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// File1
var mockMegaNzNodeForFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForFile1.Object, fileName, ItemType.File, @"\" + fileName, size * 2, lastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(2);
commandList[0].Should().BeOfType <DeleteFileCommand>();
var deleteCommand = (DeleteFileCommand)commandList[0];
deleteCommand.PathToDelete.Should().Be(remoteFile1.Path);
deleteCommand.LastModifiedDate.Should().Be(lastModifiedDate);
commandList[1].Should().BeOfType <UploadFileCommand>();
var uploadCommand = (UploadFileCommand)commandList[1];
uploadCommand.DestinationPath.Should().Be(remoteRoot.Path);
uploadCommand.SourcePath.Should().Be(localBasePath.TrimEnd('\\') + localFile1.Path);
uploadCommand.LastModifiedDate.Should().Be(lastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFile1.VerifyAll();
}
public override string GetCommand(string sourcePath) =>
$"{CommandGenerator.GetCommand(sourcePath)} --pdf-engine={this.engine}";
public override string GetCommand(string sourcePath)
{
return($"{CommandGenerator.GetCommand(sourcePath)} --highlight-style \"{stylePath}\"");
}
public void TestRunToKeyFrame()
{
bool tested = false;
var expectedCmd = new MixEffectKeyFlyRunSetCommand();
bool ignoreInfinite = false;
Func <Lazy <ImmutableList <ICommand> >, ICommand, IEnumerable <ICommand> > handler = (previousCommands, cmd) =>
{
string[] ignoreProps = ignoreInfinite ? new[] { "RunToInfinite" } : new string[] { };
if (CommandGenerator.ValidateCommandMatches(cmd, expectedCmd, false, ignoreProps))
{
// Accept it
return(new ICommand[] { null });
}
return(new ICommand[0]);
};
AtemMockServerWrapper.Each(Output, Pool, handler, DeviceTestCases.All, helper =>
{
SelectionOfKeyers <IBMDSwitcherKeyFlyParameters>(helper, (stateBefore, keyerBefore, sdkKeyer, meId, keyId, i) =>
{
tested = true;
expectedCmd.MixEffectIndex = meId;
expectedCmd.KeyerIndex = keyId;
for (int o = 0; o < 5; o++)
{
var targetFrame = Randomiser.RangeInt(2) > 0
? FlyKeyKeyFrameType.RunToInfinite
: Randomiser.EnumValue <FlyKeyKeyFrameType>(FlyKeyKeyFrameType.None);
var targetInfinite = Randomiser.EnumValue <FlyKeyLocation>();
ignoreInfinite = targetFrame != FlyKeyKeyFrameType.RunToInfinite;
expectedCmd.KeyFrame = targetFrame;
expectedCmd.RunToInfinite = targetInfinite;
/*expectedCmd.Mask = targetFrame == FlyKeyKeyFrameType.RunToInfinite
* ? MixEffectKeyFlyRunSetCommand.MaskFlags.RunToInfinite |
* MixEffectKeyFlyRunSetCommand.MaskFlags.KeyFrame
* : MixEffectKeyFlyRunSetCommand.MaskFlags.KeyFrame;*/
helper.SendAndWaitForChange(stateBefore, () =>
{
_BMDSwitcherFlyKeyFrame destination;
switch (targetFrame)
{
case FlyKeyKeyFrameType.None:
case FlyKeyKeyFrameType.A:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameA;
break;
case FlyKeyKeyFrameType.B:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameB;
break;
case FlyKeyKeyFrameType.Full:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameFull;
break;
case FlyKeyKeyFrameType.RunToInfinite:
switch (targetInfinite)
{
case FlyKeyLocation.CentreOfKey:
destination = _BMDSwitcherFlyKeyFrame
.bmdSwitcherFlyKeyFrameInfinityCentreOfKey;
break;
case FlyKeyLocation.TopLeft:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameInfinityTopLeft;
break;
case FlyKeyLocation.TopCentre:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameInfinityTop;
break;
case FlyKeyLocation.TopRight:
destination = _BMDSwitcherFlyKeyFrame
.bmdSwitcherFlyKeyFrameInfinityTopRight;
break;
case FlyKeyLocation.MiddleLeft:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameInfinityLeft;
break;
case FlyKeyLocation.MiddleCentre:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameInfinityCentre;
break;
case FlyKeyLocation.MiddleRight:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameInfinityRight;
break;
case FlyKeyLocation.BottomLeft:
destination = _BMDSwitcherFlyKeyFrame
.bmdSwitcherFlyKeyFrameInfinityBottomLeft;
break;
case FlyKeyLocation.BottomCentre:
destination = _BMDSwitcherFlyKeyFrame.bmdSwitcherFlyKeyFrameInfinityBottom;
break;
case FlyKeyLocation.BottomRight:
destination = _BMDSwitcherFlyKeyFrame
.bmdSwitcherFlyKeyFrameInfinityBottomRight;
break;
default:
throw new ArgumentOutOfRangeException();
}
break;
default:
throw new ArgumentOutOfRangeException();
}
sdkKeyer.RunToKeyFrame(destination);
});
}
});
});
Assert.True(tested);
}
private static Func <Lazy <ImmutableList <ICommand> >, ICommand, IEnumerable <ICommand> > CreateAutoCommandHandler(string name)
{
return(CommandGenerator.CreateAutoCommandHandler <AudioMixerInputSetCommand, AudioMixerInputGetV8Command>(name));
}
public static List <CommandArgument> PredictUnspecifiedArguments(Command command, List <CommandArgument> arguments)
{
var usages = GetCommandUsages(command);
var scoredUsages = new List <Tuple <CommandUsage, double> >();
foreach (var usage in usages)
{
var nScored = 0;
var totalSimilarity = 0.0;
var maxArgIndex = Math.Min(arguments.Count, usage.Executor.Arguments.Count);
var useful = false;
for (var index = 0; index < maxArgIndex; index++)
{
var usageArgument = usage.Executor.Arguments[index];
if (!usageArgument.IsSpecified)
{
continue;
}
var curArgument = arguments[index];
if (!curArgument.IsSpecified)
{
useful = useful || usageArgument.IsSpecified;
continue;
}
totalSimilarity += CommandGenerator.ScoreSimilarity(curArgument.FacetMoniker, usageArgument.FacetMoniker);
nScored++;
}
if (useful && nScored > 0)
{
scoredUsages.Add(Tuple.Create(usage, totalSimilarity / nScored));
}
}
scoredUsages = scoredUsages.OrderByDescending(x => x.Item2).ToList();
var rvl = new List <CommandArgument>();
for (var i = 0; i < arguments.Count; i++)
{
if (arguments[i].IsSpecified)
{
rvl.Add(arguments[i]);
continue;
}
var parameter = command.Parameters[i];
var argument = CommandArgument.Unspecified;
var usageMonikers = scoredUsages
.Select(x => x.Item1.Executor.Arguments[i])
.Where(x => x.IsSpecified && parameter.IsUsableAsArgument(x.FacetMoniker))
.Select(x => x.FacetMoniker)
.ToArray();
if (usageMonikers.Length > 0)
{
argument = new CommandArgument(usageMonikers, !parameter.Optional);
}
else
{
var mostUsed = GetMostUsedFacets(parameter, 5);
if (mostUsed.Length > 0)
{
argument = new CommandArgument(mostUsed, !parameter.Optional);
}
}
rvl.Add(argument);
}
return(rvl);
}
public LongNameHandler(uint targetBytes, ITestOutputHelper output, VideoSource index, bool hasMultiview)
: base(targetBytes, output, 0xffff, (uint)index, DataTransferUploadRequestCommand.TransferMode.Clear2 | DataTransferUploadRequestCommand.TransferMode.Write)
{
_hasMultiview = hasMultiview;
_propHandler = CommandGenerator.CreateAutoCommandHandler <InputPropertiesSetCommand, InputPropertiesGetCommand>("LongName");
}
public override string GetCommand(string sourcePath) =>
$"{CommandGenerator.GetCommand(sourcePath)} -V {key}:{value}";
public override string GetCommand(string sourcePath) => $"{CommandGenerator.GetCommand(sourcePath)} -N";
public async Task MasterVolumeUp() => _socketService.SendPacket(CommandGenerator.MasterVolumeCommandGenerator(MasterVolumeCommandEnum.Up));
public void GenerateCommandList_withAFileInFolderInTheLocalRootThatIsNotInTheRemoteFolder_shouldGenerateAnUploadCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif 2016-1-1-0-0-0
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
// |
// +--> (no file in the root)
//
// Then the generated command list should be:
// - Upload \root\Folder1\File1.jpeg
// Local file structure
const string folderName = "Folder1";
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localFile1 = new FileItem(ItemType.File, @"\" + folderName + @"\File1.jpeg", 1024, lastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFolder1,
localFile1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForFolder1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForFolder1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1
};
// Act
const string localBasePath = "c:\\testing\\";
var generator = new CommandGenerator(localBasePath);
var commandList = generator.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Count.Should().Be(1);
commandList[0].Should().BeOfType <UploadFileCommand>();
var uploadCommand = (UploadFileCommand)commandList[0];
uploadCommand.SourcePath.Should().Be(@"c:\testing\Folder1\File1.jpeg");
uploadCommand.DestinationPath.Should().Be(@"\Folder1\"); // We must have the backslash at the end of the path for a folder
uploadCommand.LastModifiedDate.Should().Be(lastModifiedDate);
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForFolder1.VerifyAll();
}
public void MasterVolumeDown() => _socketService.SendPacket(CommandGenerator.MasterVolumeCommandGenerator(MasterVolumeCommandEnum.Down));
public void GenerateCommandList_withAFileInFolderInTheLocalRootThatIsTheSameInTheRemoteFolder_shouldNotGenerateAnyCommand()
{
// Given the following local file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// And given the following remote file structure:
// root
// |
// +--> Folder1
// |
// +--> File1.jpeg - Last Modif = 2016-1-1-0-0-0 - Size = 1024
//
// Then the generated an empty command list
const string fileName = "File1.jpeg";
const long size = 1024;
const string folderName = "Folder1";
var lastModifiedDate = new DateTime(2016, 1, 1, 0, 0, 0);
// Local file structure
var localRoot = new FileItem(ItemType.Folder, @"\", 0);
var localFolder1 = new FileItem(ItemType.Folder, @"\" + folderName, 0);
var localFile1 = new FileItem(ItemType.File, @"\" + fileName, size, lastModifiedDate);
var localItems = new List <FileItem> {
localRoot,
localFolder1,
localFile1
};
// Remote file structure
// Root
var mockMegaNzNodeForRemoteRoot = new Mock <INode>(MockBehavior.Strict);
var remoteRoot = new MegaNzItem(mockMegaNzNodeForRemoteRoot.Object, @"\", ItemType.Folder, @"\", 0);
// Folder1
var mockMegaNzNodeForRemoteFolder1 = new Mock <INode>(MockBehavior.Strict);
var remoteFolder1 = new MegaNzItem(mockMegaNzNodeForRemoteFolder1.Object, folderName, ItemType.Folder, @"\" + folderName, 0);
// File1
var mockMegaNzNodeForRemoteFile1 = new Mock <INode>(MockBehavior.Strict);
var remoteFile1 = new MegaNzItem(mockMegaNzNodeForRemoteFile1.Object, fileName, ItemType.File, @"\" + fileName, size, lastModifiedDate);
var remoteItems = new List <MegaNzItem> {
remoteRoot,
remoteFolder1,
remoteFile1
};
// Act
const string localBasePath = "c:\\testing\\";
var synchronizer = new CommandGenerator(localBasePath);
var commandList = synchronizer.GenerateCommandList(localItems, remoteItems);
// Assert
commandList.Should().BeEmpty();
mockMegaNzNodeForRemoteRoot.VerifyAll();
mockMegaNzNodeForRemoteFolder1.VerifyAll();
mockMegaNzNodeForRemoteFile1.VerifyAll();
}
public void MasterVolumeStatus() => _socketService.SendPacket(CommandGenerator.MasterVolumeCommandGenerator(MasterVolumeCommandEnum.Status));
public override string GetCommand(string sourcePath) => $"{CommandGenerator.GetCommand(sourcePath)} --log=\"{logFilePath}\"";
public void PowerOn() => _socketService.SendPacket(CommandGenerator.PowerCommandGenerator(PowerCommandEnum.On));
