public void TestSource()
{
AtemMockServerWrapper.Each(_output, _pool, SourceCommandHandler, DeviceTestCases.All, helper =>
{
Dictionary <VideoSource, IBMDSwitcherInputAux> allAuxes = helper.GetSdkInputsOfType <IBMDSwitcherInputAux>();
VideoSource[] chosenIds = VideoSourceUtil.TakeSelection(allAuxes.Keys.ToArray());
foreach (VideoSource auxSource in chosenIds)
{
uint auxId = AtemEnumMaps.GetAuxId(auxSource);
IBMDSwitcherInputAux aux = allAuxes[auxSource];
// GetInputAvailabilityMask is used when checking if another input can be used for this output.
// We track this another way
aux.GetInputAvailabilityMask(out _BMDSwitcherInputAvailability availabilityMask);
Assert.Equal(availabilityMask, (_BMDSwitcherInputAvailability)((int)SourceAvailability.Auxiliary << 2));
AtemState stateBefore = helper.Helper.BuildLibState();
VideoSource[] validSources = stateBefore.Settings.Inputs.Where(
i => i.Value.Properties.SourceAvailability.HasFlag(SourceAvailability.Auxiliary)
).Select(i => i.Key).ToArray();
var sampleSources = VideoSourceUtil.TakeSelection(validSources);
foreach (VideoSource src in sampleSources)
{
stateBefore.Auxiliaries[(int)auxId].Source = src;
helper.SendAndWaitForChange(stateBefore, () =>
{
aux.SetInputSource((long)src);
});
}
}
});
}
public void TestLockAndUnlock()
{
AtemMockServerWrapper.Each(_output, _pool, UploadJobWorker.LockCommandHandler, DeviceTestCases.MediaPlayerClips, helper =>
{
helper.DisposeSdkClient = true;
int clipCount = helper.Helper.BuildLibState().MediaPool.Clips.Count;
for (int index = 0; index < clipCount; index++)
{
IBMDSwitcherClip clip = GetClip(helper, (uint)index);
AtemState stateBefore = helper.Helper.BuildLibState();
var cb = new LockCallback();
helper.SendAndWaitForChange(stateBefore, () => { clip.Lock(cb); });
Assert.True(cb.Wait.WaitOne(2000));
helper.Helper.CheckStateChanges(stateBefore);
uint timeBefore = helper.Server.CurrentTime;
helper.SendAndWaitForChange(stateBefore, () => { clip.Unlock(cb); });
// It should have sent a response, but we dont expect any comparable data
Assert.NotEqual(timeBefore, helper.Server.CurrentTime);
helper.Helper.CheckStateChanges(stateBefore);
}
});
}
public void TestClipSetValid()
{
AtemMockServerWrapper.Each(_output, _pool, SetValidCommandHandler, DeviceTestCases.MediaPlayerClips, helper =>
{
for (int i = 0; i < 3; i++)
{
AtemState stateBefore = helper.Helper.BuildLibState();
uint index = Randomiser.RangeInt((uint)stateBefore.MediaPool.Clips.Count);
IBMDSwitcherClip clip = GetClip(helper, index);
string name = Guid.NewGuid().ToString();
uint frameCount = Randomiser.RangeInt(5) + 3;
var cb = new LockCallback();
helper.SendAndWaitForChange(stateBefore, () => { clip.Lock(cb); });
Assert.True(cb.Wait.WaitOne(2000));
var clipState = stateBefore.MediaPool.Clips[(int)index];
clipState.IsUsed = true;
clipState.Name = name;
clipState.FrameCount = frameCount;
helper.SendAndWaitForChange(stateBefore, () =>
{
clip.SetValid(name, frameCount);
});
helper.SendAndWaitForChange(stateBefore, () =>
{
clip.Unlock(cb);
});
}
});
}
public void TestRunStatus()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.All, helper =>
{
var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl;
Assert.NotNull(control);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count);
var status = Randomiser.EnumValue <MacroState.MacroRunStatus>();
stateBefore.Macros.RunStatus.RunIndex = index;
stateBefore.Macros.RunStatus.RunStatus = status;
helper.SendAndWaitForChange(stateBefore, () =>
{
helper.Server.SendCommands(new MacroRunStatusGetCommand
{
Index = index,
IsWaiting = status == MacroState.MacroRunStatus.UserWait,
IsRunning = status == MacroState.MacroRunStatus.Running,
Loop = stateBefore.Macros.RunStatus.Loop,
});
});
}
});
}
public void TestStop()
{
var expectedCommand = RunThroughSerialize(new MacroActionCommand
{
Action = MacroActionCommand.MacroAction.Stop
});
var handler = CommandGenerator.MatchCommand(expectedCommand);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.All, helper =>
{
var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl;
Assert.NotNull(control);
uint timeBefore = helper.Server.CurrentTime;
AtemState stateBefore = helper.Helper.BuildLibState();
helper.SendAndWaitForChange(stateBefore, () =>
{
control.StopRunning();
});
// It should have sent a response, but we dont expect any comparable data
Assert.NotEqual(timeBefore, helper.Server.CurrentTime);
});
}
private static void MixMinusOutputs(AtemState state, IBMDSwitcher switcher)
{
var iterator = AtemSDKConverter.CastSdk <IBMDSwitcherMixMinusOutputIterator>(switcher.CreateIterator);
state.Settings.MixMinusOutputs = AtemSDKConverter.IterateList <IBMDSwitcherMixMinusOutput, SettingsState.MixMinusOutputState>(iterator.Next,
(props, id) =>
{
props.GetAvailableAudioModes(out _BMDSwitcherMixMinusOutputAudioMode availableModes);
props.GetAudioMode(out _BMDSwitcherMixMinusOutputAudioMode mode);
props.HasMinusAudioInputId(out int hasInputId);
long inputId = 0;
if (hasInputId != 0)
{
props.GetMinusAudioInputId(out inputId);
}
return(new SettingsState.MixMinusOutputState
{
HasAudioInputId = hasInputId != 0,
AudioInputId = (AudioSource)inputId,
SupportedModes = AtemEnumMaps.MixMinusModeMap.FindFlagsByValue(availableModes),
Mode = AtemEnumMaps.MixMinusModeMap.FindByValue(mode),
});
});
}
public void TestRecordPause()
{
var expectedCommand = new MacroAddTimedPauseCommand();
var handler = CommandGenerator.MatchCommand(expectedCommand);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.All, helper =>
{
var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl;
Assert.NotNull(control);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
uint frames = Randomiser.RangeInt(2500);
expectedCommand.Frames = frames;
uint timeBefore = helper.Server.CurrentTime;
helper.SendAndWaitForChange(stateBefore, () => { control.RecordPause(frames); });
// It should have sent a response, but we dont expect any comparable data
Assert.NotEqual(timeBefore, helper.Server.CurrentTime);
}
});
}
public void TestRcaToXlrEnabled()
{
var handler = CommandGenerator.CreateAutoCommandHandler <FairlightMixerInputSetCommand, FairlightMixerInputGetCommand>("RcaToXlrEnabled");
bool tested = false;
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightXLR, helper =>
{
IEnumerable <long> useIds = helper.Helper.BuildLibState().Fairlight.Inputs.Keys.ToList();
foreach (long id in useIds)
{
IBMDSwitcherFairlightAudioInput input = GetInput(helper, id);
if (input is IBMDSwitcherFairlightAudioInputXLR xlrInput)
{
AtemState stateBefore = helper.Helper.BuildLibState();
FairlightAudioState.InputState inputState = stateBefore.Fairlight.Inputs[id];
xlrInput.HasRCAToXLR(out int isAvailable);
Assert.Equal(1, isAvailable);
tested = true;
for (int i = 0; i < 5; i++)
{
inputState.Analog.InputLevel = i % 2 != 0
? FairlightAnalogInputLevel.ConsumerLine
: FairlightAnalogInputLevel.ProLine;
helper.SendAndWaitForChange(stateBefore, () => { xlrInput.SetRCAToXLREnabled(i % 2); });
}
}
}
});
Assert.True(tested);
}
public void TestActiveConfiguration()
{
var handler = CommandGenerator.CreateAutoCommandHandler <FairlightMixerInputSetCommand, FairlightMixerInputGetCommand>("ActiveConfiguration");
bool tested = false;
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
IEnumerable <long> useIds = Randomiser.SelectionOfGroup(helper.Helper.BuildLibState().Fairlight.Inputs.Keys.ToList());
foreach (long id in useIds)
{
IBMDSwitcherFairlightAudioInput input = GetInput(helper, id);
AtemState stateBefore = helper.Helper.BuildLibState();
FairlightAudioState.InputState inputState = stateBefore.Fairlight.Inputs[id];
var testConfigs = AtemSDKConverter.GetFlagsValues(input.GetSupportedConfigurations,
AtemEnumMaps.FairlightInputConfigurationMap);
// Need more than 1 config to allow for switching around
if (1 == testConfigs.Count)
{
continue;
}
tested = true;
for (int i = 0; i < 5; i++)
{
var target = testConfigs[i % testConfigs.Count];
inputState.ActiveConfiguration = target.Item2;
helper.SendAndWaitForChange(stateBefore, () => { input.SetConfiguration(target.Item1); });
}
}
});
Assert.True(tested);
}
public void TestPeriodicFlushInterval()
{
var handler =
CommandGenerator.CreateAutoCommandHandler <CameraControlSettingsSetCommand, CameraControlSettingsGetCommand>("Interval", true);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.CameraControl, helper =>
{
helper.Helper.StateSettings.IgnoreUnknownCameraControlProperties = true;
IBMDSwitcherCameraControl camera = helper.SdkClient.SdkSwitcher as IBMDSwitcherCameraControl;
Assert.NotNull(camera);
for (int i = 0; i < 5; i++)
{
AtemState stateBefore = helper.Helper.BuildLibState();
uint interval = Randomiser.RangeInt(int.MaxValue);
stateBefore.CameraControl.PeriodicFlushInterval = interval;
helper.SendAndWaitForChange(stateBefore, () =>
{
camera.SetPeriodicFlushInterval(interval);
});
}
});
}
public void TestInputTalkbackGain()
{
var handler = CommandGenerator.CreateAutoCommandHandler <FairlightMixerMonitorSetCommand, FairlightMixerMonitorGetCommand>("InputTalkbackGain");
bool tested = false;
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper =>
{
var monitor = GetMonitor(helper);
if (monitor == null)
{
return;
}
tested = true;
AtemState stateBefore = helper.Helper.BuildLibState();
FairlightAudioState.MonitorOutputState monState = stateBefore.Fairlight.Monitors.Single();
for (int i = 0; i < 5; i++)
{
var target = Randomiser.Range(-60, 0);
monState.InputTalkbackGain = target;
helper.SendAndWaitForChange(stateBefore, () => { monitor.SetInputTalkbackGain(target); });
}
});
Assert.True(tested);
}
public static void Update(AtemState state, UpdateResultImpl result, ICommand command)
{
if (command is TalkbackMixerPropertiesGetCommand talkbackCmd)
{
UpdaterUtil.TryForIndex(result, state.Settings.Talkback, (int)talkbackCmd.Channel, channel =>
{
channel.MuteSDI = talkbackCmd.MuteSDI;
result.SetSuccess($"Settings.Talkback.{talkbackCmd.Channel:D}");
});
}
else if (command is TalkbackMixerInputPropertiesGetCommand inputCmd)
{
UpdaterUtil.TryForIndex(result, state.Settings.Talkback, (int)inputCmd.Channel, channel =>
{
if (!channel.Inputs.TryGetValue(inputCmd.Index, out SettingsState.TalkbackInputState input))
{
input = channel.Inputs[inputCmd.Index] = new SettingsState.TalkbackInputState();
}
UpdaterUtil.CopyAllProperties(inputCmd, input, new[] { "Channel", "Index" });
result.SetSuccess($"Settings.Talkback.{inputCmd.Channel:D}.Inputs.{inputCmd.Index:D}");
});
}
}
public void TestClone()
{
var state = new AtemState();
// Simply ensure it can be cloned, as it relies on all classes having an attribute
state.Clone();
}
public void TestTally()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.ClassicAudioMain, helper =>
{
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
var cmd = new AudioMixerTallyCommand
{
Inputs = new Dictionary <AudioSource, bool>()
};
Assert.NotEmpty(stateBefore.Audio.Tally);
// the sdk is a bit picky about ids, so best to go with what it expects
foreach (KeyValuePair <AudioSource, bool> k in stateBefore.Audio.Tally)
{
bool isMixedIn = Randomiser.Range(0, 1) > 0.7;
cmd.Inputs[k.Key] = isMixedIn;
}
stateBefore.Audio.Tally = cmd.Inputs;
helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(cmd); });
}
});
}
public static IUpdateResult Update(AtemState state, ICommand command, AtemStateBuilderSettings settings = null)
{
var result = new UpdateResultImpl();
UpdateInternal(state, result, command);
AudioStateUpdater.Update(state, result, command);
FairlightStateUpdater.Update(state, result, command);
TalkbackStateUpdater.Update(state, result, command);
AuxStateUpdater.Update(state, result, command);
ColorStateUpdater.Update(state, result, command);
DownstreamKeyerStateUpdater.Update(state, result, command);
InfoStateUpdater.Update(state, result, command);
MacroStateUpdater.Update(state, result, command);
MediaPlayerStateUpdater.Update(state, result, command, settings);
MediaPoolStateUpdater.Update(state, result, command);
MixEffectStateUpdater.Update(state, result, command);
SettingsStateUpdater.Update(state, result, command);
HyperDeckStateUpdater.Update(state, result, command);
SuperSourceStateUpdater.Update(state, result, command);
StreamingStateUpdater.Update(state, result, command);
RecordingStateUpdater.Update(state, result, command);
CameraControllerUpdater.Update(state, result, command, settings);
return(result);
}
public void TestMode()
{
var handler = CommandGenerator.CreateAutoCommandHandler <MixMinusOutputSetCommand, MixMinusOutputGetCommand>("Mode");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.MixMinusOutputs, helper =>
{
bool tested = false;
List <IBMDSwitcherMixMinusOutput> outputs = GetMixMinusOutputs(helper);
for (int id = 0; id < outputs.Count; id++)
{
IBMDSwitcherMixMinusOutput mixMinus = outputs[id];
tested = true;
AtemState stateBefore = helper.Helper.BuildLibState();
SettingsState.MixMinusOutputState mixMinusState = stateBefore.Settings.MixMinusOutputs[id];
for (int i = 0; i < 5; i++)
{
MixMinusMode newValue = Randomiser.EnumValue <MixMinusMode>();
mixMinusState.Mode = newValue;
helper.SendAndWaitForChange(stateBefore,
() => { mixMinus.SetAudioMode(AtemEnumMaps.MixMinusModeMap[newValue]); });
}
}
Assert.True(tested);
});
}
public void SendState(AtemState state)
{
_context.Clients.Clients(GetClientIds()).SendAsync("state", new AtemStateWrapped {
State = state,
DeviceId = _deviceId
});
}
public void TestAudioInputId()
{
var handler = CommandGenerator.CreateAutoCommandHandler <MixMinusOutputSetCommand, MixMinusOutputGetCommand>("Mode");
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.MixMinusOutputs, helper =>
{
var previousCommands = helper.Server.GetParsedDataDump().OfType <MixMinusOutputGetCommand>().ToList();
for (int i = 0; i < 10; i++)
{
AtemState stateBefore = helper.Helper.BuildLibState();
uint id = Randomiser.RangeInt((uint)stateBefore.Settings.MixMinusOutputs.Count - 1);
SettingsState.MixMinusOutputState mixMinusState = stateBefore.Settings.MixMinusOutputs[(int)id];
MixMinusOutputGetCommand cmd = previousCommands.Single(c => c.Id == id);
uint newValue = Randomiser.RangeInt(9) + 1;
cmd.HasAudioInputId = i % 2 == 0;
cmd.AudioInputId = cmd.HasAudioInputId ? (AudioSource)newValue : 0;
mixMinusState.HasAudioInputId = cmd.HasAudioInputId;
mixMinusState.AudioInputId = cmd.AudioInputId;
helper.SendFromServerAndWaitForChange(stateBefore, cmd);
}
});
}
public void TestHasUnsupportedOps()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.MacroTransfer, helper =>
{
var pool = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroPool;
Assert.NotNull(pool);
ImmutableList <ICommand> previousCommands = helper.Server.GetParsedDataDump();
for (int i = 0; i < 10; i++)
{
AtemState stateBefore = helper.Helper.BuildLibState();
uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count);
MacroPropertiesGetCommand cmd = previousCommands.OfType <MacroPropertiesGetCommand>().Single(c => c.Index == index);
cmd.HasUnsupportedOps = i % 2 == 0;
stateBefore.Macros.Pool[(int)index].HasUnsupportedOps = cmd.HasUnsupportedOps;
helper.SendAndWaitForChange(stateBefore, () =>
{
helper.Server.SendCommands(cmd);
});
}
});
}
protected static void EachSuperSourceBox(AtemMockServerWrapper helper, Action <AtemState, SuperSourceState.BoxState, IBMDSwitcherSuperSourceBox, SuperSourceId, SuperSourceBoxId, int> fcn, int iterations = 5)
{
var allBoxes = new List <Tuple <SuperSourceId, SuperSourceBoxId, IBMDSwitcherSuperSourceBox> >();
foreach (KeyValuePair <VideoSource, IBMDSwitcherInputSuperSource> ssrc in helper.GetSdkInputsOfType <IBMDSwitcherInputSuperSource>())
{
SuperSourceId id = (SuperSourceId)(ssrc.Key - VideoSource.SuperSource);
var iterator = AtemSDKConverter.CastSdk <IBMDSwitcherSuperSourceBoxIterator>(ssrc.Value.CreateIterator);
AtemSDKConverter.Iterate <IBMDSwitcherSuperSourceBox>(iterator.Next, (box, i) =>
{
allBoxes.Add(Tuple.Create(id, (SuperSourceBoxId)i, box));
});
}
var boxes = Randomiser.SelectionOfGroup(allBoxes);
foreach (Tuple <SuperSourceId, SuperSourceBoxId, IBMDSwitcherSuperSourceBox> box in boxes)
{
AtemState stateBefore = helper.Helper.BuildLibState();
SuperSourceState.BoxState boxBefore = stateBefore.SuperSources[(int)box.Item1].Boxes[(int)box.Item2];
Assert.NotNull(boxBefore);
for (int i = 0; i < iterations; i++)
{
fcn(stateBefore, boxBefore, box.Item3, box.Item1, box.Item2, i);
}
}
}
public void TestRun()
{
var expectedCommand = RunThroughSerialize(new MacroActionCommand
{
Action = MacroActionCommand.MacroAction.Run
});
var handler = CommandGenerator.MatchCommand(expectedCommand);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.All, helper =>
{
var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl;
Assert.NotNull(control);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count);
expectedCommand.Index = index;
uint timeBefore = helper.Server.CurrentTime;
helper.SendAndWaitForChange(stateBefore, () =>
{
control.Run(index);
});
// It should have sent a response, but we dont expect any comparable data
Assert.NotEqual(timeBefore, helper.Server.CurrentTime);
}
});
}
public void CheckStateChanges(AtemState expected, Action <AtemState, AtemState> mutateStates = null)
{
AtemState sdkState = BuildSdkState();
AtemState libState = BuildLibState();
mutateStates?.Invoke(sdkState, libState);
List <string> sdk = AtemStateComparer.AreEqual(expected, sdkState);
List <string> lib = AtemStateComparer.AreEqual(expected, libState);
if (sdk.Count > 0 || lib.Count > 0)
{
if (sdk.Count > 0)
{
Output.WriteLine("SDK wrong");
sdk.ForEach(Output.WriteLine);
}
if (lib.Count > 0)
{
Output.WriteLine("Lib wrong");
lib.ForEach(Output.WriteLine);
}
TestResult = false;
}
}
public void TestRecordStatus()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.All, helper =>
{
var control = helper.SdkClient.SdkSwitcher as IBMDSwitcherMacroControl;
Assert.NotNull(control);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
uint index = Randomiser.RangeInt((uint)stateBefore.Macros.Pool.Count);
bool recording = Randomiser.RangeInt(1) == 1;
stateBefore.Macros.RecordStatus.RecordIndex = index;
stateBefore.Macros.RecordStatus.IsRecording = recording;
helper.SendAndWaitForChange(stateBefore, () =>
{
helper.Server.SendCommands(new MacroRecordingStatusGetCommand()
{
Index = index,
IsRecording = recording,
});
});
}
});
}
public void SyncStates()
{
lock (_libAtemStateLock)
{
_libAtemState = SdkClient.BuildState();
}
}
public void TestIsUsed()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.MediaPlayerClips, helper =>
{
ImmutableList <ICommand> previousCommands = helper.Server.GetParsedDataDump();
int clipCount = helper.Helper.BuildLibState().MediaPool.Clips.Count;
for (int index = 0; index < clipCount; index++)
{
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
MediaPoolClipDescriptionCommand cmd = previousCommands.OfType <MediaPoolClipDescriptionCommand>().Single(c => c.Index == index);
cmd.IsUsed = i % 2 == 0;
cmd.Name = cmd.IsUsed ? "abc" : "";
stateBefore.MediaPool.Clips[index].IsUsed = cmd.IsUsed;
stateBefore.MediaPool.Clips[index].Name = cmd.Name;
helper.SendFromServerAndWaitForChange(stateBefore, cmd);
}
}
});
}
public void TestRecordingState()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.Recording, helper =>
{
var switcher = helper.SdkClient.SdkSwitcher as IBMDSwitcherRecordAV;
Assert.NotNull(switcher);
AtemState stateBefore = helper.Helper.BuildLibState();
InitDisk(helper, stateBefore);
InitRecording(helper, stateBefore);
stateBefore.Recording.Status.TotalRecordingTimeAvailable = 0;
for (int i = 0; i < 10; i++)
{
stateBefore.Recording.Status.State = Randomiser.EnumValue <RecordingStatus>();
stateBefore.Recording.Status.Error = Randomiser.EnumValue <RecordingError>();
var cmd = new RecordingStatusGetCommand()
{
Status = stateBefore.Recording.Status.State,
Error = stateBefore.Recording.Status.Error,
};
helper.SendFromServerAndWaitForChange(stateBefore, cmd);
}
});
}
public void TestSetAudioInvalid()
{
AtemMockServerWrapper.Each(_output, _pool, ClearAudioCommandHandler, DeviceTestCases.MediaPlayerClips, helper =>
{
ImmutableList <ICommand> previousCommands = helper.Server.GetParsedDataDump();
int clipCount = helper.Helper.BuildLibState().MediaPool.Clips.Count;
for (int index = 0; index < clipCount; index++)
{
AtemState stateBefore = helper.Helper.BuildLibState();
IBMDSwitcherClip clip = GetClip(helper, (uint)index);
for (int i = 0; i < 5; i++)
{
MediaPoolAudioDescriptionCommand cmd = previousCommands
.OfType <MediaPoolAudioDescriptionCommand>().Single(c => c.Index == index + 1);
cmd.IsUsed = true;
// Set it to true first
stateBefore.MediaPool.Clips[index].Audio.IsUsed = true;
helper.SendFromServerAndWaitForChange(stateBefore, cmd);
// Now set invalid
stateBefore.MediaPool.Clips[index].Audio.IsUsed = false;
helper.SendAndWaitForChange(stateBefore, () => { clip.SetAudioInvalid(); });
}
}
});
}
public void TestDiskRemoval()
{
var handler = CommandGenerator.CreateAutoCommandHandler <RecordingStatusSetCommand, RecordingStatusGetCommand>("IsRecording", true);
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.Streaming, helper =>
{
var switcher = helper.SdkClient.SdkSwitcher as IBMDSwitcherStreamRTMP;
Assert.NotNull(switcher);
AtemState stateBefore = helper.Helper.BuildLibState();
// Init a disk that will persit
InitDisk(helper, stateBefore, 99);
for (int i = 0; i < 10; i++)
{
var id = Randomiser.RangeInt(20);
var cmd = InitDisk(helper, stateBefore, id);
// Simulate removal
cmd.IsDelete = true;
stateBefore.Recording.Disks.Remove(id);
helper.SendFromServerAndWaitForChange(stateBefore, cmd);
}
});
}
public void TestTally()
{
AtemMockServerWrapper.Each(_output, _pool, null, DeviceTestCases.FairlightMain, helper =>
{
IBMDSwitcherFairlightAudioMixer mixer = GetFairlightMixer(helper);
AtemState stateBefore = helper.Helper.BuildLibState();
for (int i = 0; i < 5; i++)
{
var cmd = new FairlightMixerTallyCommand
{
Tally = new Dictionary <Tuple <AudioSource, long>, bool>()
};
Assert.NotEmpty(stateBefore.Fairlight.Tally);
// the sdk is a bit picky about ids, so best to go with what it expects
foreach (KeyValuePair <Tuple <AudioSource, long>, bool> k in stateBefore.Fairlight.Tally)
{
bool isMixedIn = Randomiser.Range(0, 1) > 0.7;
cmd.Tally[k.Key] = isMixedIn;
}
stateBefore.Fairlight.Tally = cmd.Tally;
helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(cmd); });
}
});
}
public void TestBalance()
{
var handler = CreateAutoCommandHandler("Balance");
bool tested = false;
AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.ClassicAudioMain, helper =>
{
IEnumerable <long> useIds = helper.Helper.BuildLibState().Audio.Inputs.Keys.ToList();
foreach (long id in useIds)
{
AtemState stateBefore = helper.Helper.BuildLibState();
var inputState = stateBefore.Audio.Inputs[id].Properties;
IBMDSwitcherAudioInput input = GetInput(helper, id);
tested = true;
for (int i = 0; i < 5; i++)
{
var target = Randomiser.Range(-50, 50);
inputState.Balance = target;
helper.SendAndWaitForChange(stateBefore, () => { input.SetBalance(target / 50); });
}
}
});
Assert.True(tested);
}
