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 TestNextStyle() { bool tested = false; var handler = CommandGenerator.CreateAutoCommandHandler <TransitionPropertiesSetCommand, TransitionPropertiesGetCommand>("NextStyle"); AtemMockServerWrapper.Each(Output, Pool, handler, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherTransitionParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; var omitStyles = new List <TransitionStyle>(); if (stateBefore.Info.DVE == null) { omitStyles.Add(TransitionStyle.DVE); } if (stateBefore.MediaPool.Clips.Count == 0) { omitStyles.Add(TransitionStyle.Stinger); } TransitionStyle target = Randomiser.EnumValue(omitStyles.ToArray()); _BMDSwitcherTransitionStyle target2 = AtemEnumMaps.TransitionStyleMap[target]; meBefore.Transition.Properties.NextStyle = target; helper.SendAndWaitForChange(stateBefore, () => { sdk.SetNextTransitionStyle(target2); }); }); }); Assert.True(tested); }
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 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 TestPreviewInput() { var ignorePortTypes = new HashSet <InternalPortType> { InternalPortType.Mask, InternalPortType.Auxiliary, InternalPortType.MEOutput }; bool tested = false; var handler = CommandGenerator.CreateAutoCommandHandler <PreviewInputSetCommand, PreviewInputGetCommand>("Source", true); AtemMockServerWrapper.Each(Output, Pool, handler, DeviceTestCases.All, helper => { // TODO - this could be better and use the availabilitymask List <VideoSource> validSources = helper.Helper.BuildLibState().Settings.Inputs .Where(s => !ignorePortTypes.Contains(s.Value.Properties.InternalPortType)).Select(s => s.Key) .ToList(); VideoSource[] sampleSources = Randomiser.SelectionOfGroup(validSources).ToArray(); EachMixEffect <IBMDSwitcherMixEffectBlock>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; VideoSource target = sampleSources[i]; meBefore.Sources.Preview = target; helper.SendAndWaitForChange(stateBefore, () => { sdk.SetPreviewInput((long)target); }); }, sampleSources.Length); }); Assert.True(tested); }
public void TestArtKeyInput() { bool tested = false; var handler = CommandGenerator.CreateAutoCommandHandler <SuperSourcePropertiesSetV8Command, SuperSourcePropertiesGetV8Command>("ArtCutSource"); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.SuperSource, helper => { VideoSource[] validSources = helper.Helper.BuildLibState().Settings.Inputs.Where( i => i.Value.Properties.SourceAvailability.HasFlag(SourceAvailability.SuperSourceArt) ).Select(i => i.Key).ToArray(); var sampleSources = VideoSourceUtil.TakeSelection(validSources); EachSuperSource(helper, (stateBefore, ssrcBefore, sdk, ssrcId, i) => { tested = true; // TODO GetCutInputAvailabilityMask VideoSource target = sampleSources[i]; ssrcBefore.Properties.ArtCutSource = target; helper.SendAndWaitForChange(stateBefore, () => { sdk.SetInputCut((long)target); }); }, sampleSources.Length); }); Assert.True(tested); }
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 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 TestStyle() { bool tested = false; var handler = CommandGenerator.CreateAutoCommandHandler <TransitionDVESetCommand, TransitionDVEGetCommand>("Style"); AtemMockServerWrapper.Each(Output, Pool, handler, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherTransitionDVEParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { if (stateBefore.Info.DVE != null && stateBefore.Info.DVE.SupportedTransitions.Count > 0) { var selection = Randomiser .SelectionOfGroup(stateBefore.Info.DVE.SupportedTransitions.ToList(), 3).ToList(); tested = true; Assert.NotNull(meBefore.Transition.DVE); foreach (DVEEffect style in selection) { meBefore.Transition.DVE.Style = style; helper.SendAndWaitForChange(stateBefore, () => { sdk.SetStyle(AtemEnumMaps.DVEStyleMap[style]); }); } } }); }); Assert.True(tested); }
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 TestSwitchDisk() { var handler = CommandGenerator.MatchCommand(new RecordingSwitchDiskCommand()); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.Streaming, helper => { var switcher = helper.SdkClient.SdkSwitcher as IBMDSwitcherRecordAV; Assert.NotNull(switcher); var stateBefore = helper.Helper.BuildLibState(); InitDisk(helper, stateBefore, 0); InitDisk(helper, stateBefore, 1); InitRecording(helper, stateBefore, 0, 1); for (int i = 0; i < 5; i++) { uint timeBefore = helper.Server.CurrentTime; helper.SendAndWaitForChange(null, () => { switcher.SwitchDisk(); }); // It should have sent a response, but we dont expect any comparable data Assert.NotEqual(timeBefore, helper.Server.CurrentTime); } }); }
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); } } }
protected static void EachSuperSourceBorder(AtemMockServerWrapper helper, Action <AtemState, SuperSourceState.BorderState, IBMDSwitcherSuperSourceBorder, SuperSourceId, int> fcn, int iterations = 5) { EachSuperSource(helper, (stateBefore, ssrcState, sdk, ssrcId, i) => { fcn(stateBefore, ssrcState.Border, (IBMDSwitcherSuperSourceBorder)sdk, ssrcId, i); }, iterations); }
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); } }); }
protected static VideoSource[] GetTransitionSourcesSelection(AtemMockServerWrapper helper) { VideoSource[] validSources = helper.Helper.BuildLibState().Settings.Inputs.Where( i => i.Value.Properties.SourceAvailability.HasFlag(SourceAvailability.KeySource) ).Select(i => i.Key).ToArray(); return(VideoSourceUtil.TakeSelection(validSources)); }
public void TestFillSource() { bool tested = false; var handler = CommandGenerator.CreateAutoCommandHandler <TransitionDVESetCommand, TransitionDVEGetCommand>("FillSource"); AtemMockServerWrapper.Each(Output, Pool, handler, DeviceTestCases.All, helper => { VideoSource[] validSources = helper.Helper.BuildLibState().Settings.Inputs.Where( i => i.Value.Properties.SourceAvailability.HasFlag(SourceAvailability.KeySource) ).Select(i => i.Key).ToArray(); var sampleSources = VideoSourceUtil.TakeSelection(validSources); EachMixEffect <IBMDSwitcherTransitionDVEParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; Assert.NotNull(meBefore.Transition.DVE); // sdk.GetFillInputAvailabilityMask(out _BMDSwitcherInputAvailability mask); // Assert.Equal((long)SourceAvailability., (long)mask); VideoSource target = sampleSources[i]; meBefore.Transition.DVE.FillSource = target; helper.SendAndWaitForChange(stateBefore, () => { sdk.SetInputFill((long)target); }); }, sampleSources.Length); }); Assert.True(tested); }
public void TestReset() { var target = new FairlightMixerSourceDynamicsResetCommand() { Expander = true }; var handler = CommandGenerator.MatchCommand(target); AtemMockServerWrapper.Each(_output, _pool, handler, DeviceTestCases.FairlightMain, helper => { TestFairlightInputSource.EachRandomSource(helper, (stateBefore, srcState, inputId, src, i) => { IBMDSwitcherFairlightAudioExpander expander = GetExpander(src); target.Index = (AudioSource)inputId; target.SourceId = srcState.SourceId; uint timeBefore = helper.Server.CurrentTime; helper.SendAndWaitForChange(null, () => { expander.Reset(); }); // It should have sent a response, but we dont expect any comparable data Assert.NotEqual(timeBefore, helper.Server.CurrentTime); }, 1); }); }
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); }); } }); }
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 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 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 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 TestTransitionFramesRemaining() { bool tested = false; AtemMockServerWrapper.Each(Output, Pool, null, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherMixEffectBlock>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; uint target = Randomiser.RangeInt(250); meBefore.Transition.Position.RemainingFrames = target; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new TransitionPositionGetCommand { Index = meId, RemainingFrames = target, InTransition = meBefore.Transition.Position.InTransition, HandlePosition = meBefore.Transition.Position.HandlePosition }); }); }); }); Assert.True(tested); }
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 TestGetSelection() { bool tested = false; AtemMockServerWrapper.Each(Output, Pool, null, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherTransitionParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; uint maxSelectionValue = (uint)1 << meBefore.Keyers.Count; uint maxSelection = (maxSelectionValue << 1) - 1; uint target = 1 + Randomiser.RangeInt(maxSelection - 1); meBefore.Transition.Properties.Selection = (TransitionLayer)target; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new TransitionPropertiesGetCommand { Index = meId, NextStyle = meBefore.Transition.Properties.NextStyle, Style = meBefore.Transition.Properties.Style, NextSelection = meBefore.Transition.Properties.NextSelection, Selection = (TransitionLayer)target, }); }); }); }); Assert.True(tested); }
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 TestGetStyle() { bool tested = false; AtemMockServerWrapper.Each(Output, Pool, null, DeviceTestCases.All, helper => { EachMixEffect <IBMDSwitcherTransitionParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; TransitionStyle target = Randomiser.EnumValue <TransitionStyle>(); meBefore.Transition.Properties.Style = target; helper.SendAndWaitForChange(stateBefore, () => { helper.Server.SendCommands(new TransitionPropertiesGetCommand { Index = meId, NextStyle = meBefore.Transition.Properties.NextStyle, Style = target, NextSelection = meBefore.Transition.Properties.NextSelection, Selection = meBefore.Transition.Properties.Selection, }); }); }); }); Assert.True(tested); }
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); }); }
public static IBMDSwitcherFairlightAudioMixer GetFairlightMixer(AtemMockServerWrapper helper) { var mixer = helper.Helper.SdkSwitcher as IBMDSwitcherFairlightAudioMixer; Assert.NotNull(mixer); return(mixer); }
public void TestSource() { bool tested = false; var handler = CommandGenerator.CreateAutoCommandHandler <TransitionStingerSetCommand, TransitionStingerGetCommand>("Source"); AtemMockServerWrapper.Each(Output, Pool, handler, DeviceTestCases.All, helper => { int mpCount = helper.Helper.BuildLibState().MediaPlayers.Count; List <StingerSource> sources = Enum.GetValues(typeof(StingerSource)).OfType <StingerSource>().Where(s => ((int)s) < mpCount).ToList(); if (sources.Count <= 1) { return; } EachMixEffect <IBMDSwitcherTransitionStingerParameters>(helper, (stateBefore, meBefore, sdk, meId, i) => { tested = true; Assert.NotNull(meBefore.Transition.Stinger); StingerSource target = sources[i]; _BMDSwitcherStingerTransitionSource target2 = AtemEnumMaps.StingerSourceMap[target]; meBefore.Transition.Stinger.Source = target; helper.SendAndWaitForChange(stateBefore, () => { sdk.SetSource(target2); }); }, sources.Count); }); Assert.True(tested); }