647 lines
22 KiB
C#
647 lines
22 KiB
C#
using System.Collections.Concurrent;
|
|
using MBN_STOCK_WEBVIEW.Playout.Configuration;
|
|
using MBN_STOCK_WEBVIEW.Playout.Interop;
|
|
using MBN_STOCK_WEBVIEW.Playout.Runtime;
|
|
|
|
namespace MBN_STOCK_WEBVIEW.Playout.Tests;
|
|
|
|
public sealed class DynamicK3dSessionTests
|
|
{
|
|
[Theory]
|
|
[InlineData(0)]
|
|
[InlineData(-1)]
|
|
public async Task Connect_WhenKtapDoesNotReturnOne_FailsClosed(int connectResult)
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var log = new FakeComLog();
|
|
var engine = new FakeEngine(
|
|
log,
|
|
new FakePlayer(log),
|
|
new FakeScene(log),
|
|
connectResult);
|
|
var activator = new FakeActivator(log, engine);
|
|
var releaser = new FakeReleaser(
|
|
log,
|
|
(engine, "Engine"),
|
|
(activator.EventHandler, "EventHandler"));
|
|
await using var dispatcher = new StaDispatcher(capacity: 1);
|
|
|
|
var exception = await Assert.ThrowsAnyAsync<Exception>(
|
|
() => dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using var session = new DynamicK3dSession(activator, releaser);
|
|
try
|
|
{
|
|
session.Connect(options);
|
|
}
|
|
catch
|
|
{
|
|
Assert.False(session.IsConnected);
|
|
Assert.Equal(
|
|
PlayoutKtapConnectState.Failed,
|
|
session.LastKtapConnectState);
|
|
throw;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None));
|
|
|
|
Assert.DoesNotContain(options.Host, exception.Message, StringComparison.OrdinalIgnoreCase);
|
|
Assert.DoesNotContain(scenes.Path, exception.Message, StringComparison.OrdinalIgnoreCase);
|
|
Assert.DoesNotContain(connectResult.ToString(), exception.Message, StringComparison.Ordinal);
|
|
Assert.DoesNotContain("GetScenePlayer", log.Names);
|
|
Assert.Equal(
|
|
new[]
|
|
{
|
|
$"Create:{K3dComConstants.KaEventHandlerClassGuid:B}",
|
|
$"Create:{K3dComConstants.KaEngineClassGuid:B}",
|
|
"KTAPConnect:1:127.0.0.1:30001:0",
|
|
"Disconnect",
|
|
"Release:Engine",
|
|
"Release:EventHandler"
|
|
},
|
|
log.Names);
|
|
Assert.Equal(1, log.Names.Count(name => name == "Disconnect"));
|
|
Assert.Single(log.ThreadIds.Distinct());
|
|
Assert.All(log.ApartmentStates, state => Assert.Equal(ApartmentState.STA, state));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Connect_WhenPlayerInitializationFails_DisconnectsOnceAndPreservesOriginalFailure()
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var log = new FakeComLog();
|
|
var originalFailure = new InvalidOperationException("fake original player failure");
|
|
var engine = new FakeEngine(
|
|
log,
|
|
new FakePlayer(log),
|
|
new FakeScene(log),
|
|
playerFailure: originalFailure,
|
|
disconnectFailure: new InvalidOperationException("fake cleanup failure"));
|
|
var activator = new FakeActivator(log, engine);
|
|
var releaser = new FakeReleaser(
|
|
log,
|
|
(engine, "Engine"),
|
|
(activator.EventHandler, "EventHandler"));
|
|
await using var dispatcher = new StaDispatcher(capacity: 1);
|
|
var lastKtapConnectState = PlayoutKtapConnectState.NotAttempted;
|
|
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using var session = new DynamicK3dSession(activator, releaser);
|
|
try
|
|
{
|
|
session.Connect(options);
|
|
}
|
|
finally
|
|
{
|
|
lastKtapConnectState = session.LastKtapConnectState;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None));
|
|
|
|
Assert.Same(originalFailure, exception);
|
|
Assert.Equal(PlayoutKtapConnectState.AcceptedUnconfirmed, lastKtapConnectState);
|
|
Assert.Equal(
|
|
new[]
|
|
{
|
|
$"Create:{K3dComConstants.KaEventHandlerClassGuid:B}",
|
|
$"Create:{K3dComConstants.KaEngineClassGuid:B}",
|
|
"KTAPConnect:1:127.0.0.1:30001:0",
|
|
"GetScenePlayerOnChannel:9",
|
|
"Disconnect",
|
|
"Release:Engine",
|
|
"Release:EventHandler"
|
|
},
|
|
log.Names);
|
|
Assert.Equal(1, log.Names.Count(name => name == "Disconnect"));
|
|
Assert.Single(log.ThreadIds.Distinct());
|
|
Assert.All(log.ApartmentStates, state => Assert.Equal(ApartmentState.STA, state));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Connect_WhenKtapInvocationThrows_AttemptsDisconnectAndPreservesOriginalFailure()
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var log = new FakeComLog();
|
|
var originalFailure = new InvalidOperationException("fake original KTAP failure");
|
|
var engine = new FakeEngine(
|
|
log,
|
|
new FakePlayer(log),
|
|
new FakeScene(log),
|
|
connectFailure: originalFailure);
|
|
var activator = new FakeActivator(log, engine);
|
|
var releaser = new FakeReleaser(
|
|
log,
|
|
(engine, "Engine"),
|
|
(activator.EventHandler, "EventHandler"));
|
|
await using var dispatcher = new StaDispatcher(capacity: 1);
|
|
var lastKtapConnectState = PlayoutKtapConnectState.NotAttempted;
|
|
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using var session = new DynamicK3dSession(activator, releaser);
|
|
try
|
|
{
|
|
session.Connect(options);
|
|
}
|
|
finally
|
|
{
|
|
lastKtapConnectState = session.LastKtapConnectState;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None));
|
|
|
|
Assert.Same(originalFailure, exception);
|
|
Assert.Equal(PlayoutKtapConnectState.Failed, lastKtapConnectState);
|
|
Assert.Equal(
|
|
new[]
|
|
{
|
|
$"Create:{K3dComConstants.KaEventHandlerClassGuid:B}",
|
|
$"Create:{K3dComConstants.KaEngineClassGuid:B}",
|
|
"KTAPConnect:1:127.0.0.1:30001:0",
|
|
"Disconnect",
|
|
"Release:Engine",
|
|
"Release:EventHandler"
|
|
},
|
|
log.Names);
|
|
Assert.Equal(1, log.Names.Count(name => name == "Disconnect"));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(PlayoutTakeOutScope.All, "StopAll")]
|
|
[InlineData(PlayoutTakeOutScope.Layout, "CutOut:10")]
|
|
public async Task FakeLateBoundCom_UsesLegacyCallOrderOnOneStaThread(
|
|
PlayoutTakeOutScope takeOutScope,
|
|
string expectedTakeOutCall)
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var cue = options.ResolveCue(new PlayoutCue(
|
|
"test-scene.t2s",
|
|
"test-scene",
|
|
[
|
|
new PlayoutField("headline", "safe value", true),
|
|
new PlayoutField("badge", null, false)
|
|
],
|
|
FadeDuration: 12));
|
|
var log = new FakeComLog();
|
|
var player = new FakePlayer(log);
|
|
var scene = new FakeScene(log);
|
|
var engine = new FakeEngine(log, player, scene);
|
|
var activator = new FakeActivator(log, engine);
|
|
await using var dispatcher = new StaDispatcher(capacity: 4);
|
|
|
|
await dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using var session = new DynamicK3dSession(activator);
|
|
session.Connect(options);
|
|
Assert.Equal(
|
|
PlayoutKtapConnectState.AcceptedUnconfirmed,
|
|
session.LastKtapConnectState);
|
|
session.Prepare(cue, options.LayoutIndex);
|
|
session.Play(options.LayoutIndex);
|
|
session.TakeOut(options.LayoutIndex, takeOutScope);
|
|
session.Disconnect();
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None);
|
|
|
|
Assert.Equal(
|
|
new[]
|
|
{
|
|
$"Create:{K3dComConstants.KaEventHandlerClassGuid:B}",
|
|
$"Create:{K3dComConstants.KaEngineClassGuid:B}",
|
|
"KTAPConnect:1:127.0.0.1:30001:0",
|
|
"GetScenePlayerOnChannel:9",
|
|
"LoadScene:test-scene",
|
|
"SetSceneEffectType:10:7:12",
|
|
"BeginTransaction",
|
|
"GetObject:headline",
|
|
"SetValue:headline:safe value",
|
|
"SetVisible:headline:1",
|
|
"GetObject:badge",
|
|
"SetVisible:badge:0",
|
|
"QueryVariables",
|
|
"EndTransaction",
|
|
"Prepare:10",
|
|
"Play:10",
|
|
expectedTakeOutCall,
|
|
"Disconnect"
|
|
},
|
|
log.Names);
|
|
Assert.Single(log.ThreadIds.Distinct());
|
|
Assert.All(log.ApartmentStates, state => Assert.Equal(ApartmentState.STA, state));
|
|
}
|
|
|
|
[Fact]
|
|
public void LateBoundActivatorContract_AcceptsOnlyAClsid()
|
|
{
|
|
var create = typeof(ILateBoundComActivator).GetMethod(nameof(ILateBoundComActivator.Create));
|
|
|
|
Assert.NotNull(create);
|
|
Assert.Equal(typeof(Guid), Assert.Single(create.GetParameters()).ParameterType);
|
|
Assert.Equal(typeof(object), create.ReturnType);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Connect_WhenComActivationFails_ReportsKtapNotAttempted()
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var originalFailure = new InvalidOperationException("fake activation failure");
|
|
var lastKtapConnectState = PlayoutKtapConnectState.Failed;
|
|
await using var dispatcher = new StaDispatcher(capacity: 1);
|
|
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using var session = new DynamicK3dSession(
|
|
new ThrowingActivator(originalFailure));
|
|
try
|
|
{
|
|
session.Connect(options);
|
|
}
|
|
finally
|
|
{
|
|
lastKtapConnectState = session.LastKtapConnectState;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None));
|
|
|
|
Assert.Same(originalFailure, exception);
|
|
Assert.Equal(PlayoutKtapConnectState.NotAttempted, lastKtapConnectState);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PreventKtapConnect_DuringActivation_BlocksLateDispatch()
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
using var activationStarted = new ManualResetEventSlim();
|
|
using var releaseActivation = new ManualResetEventSlim();
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var log = new FakeComLog();
|
|
var engine = new FakeEngine(log, new FakePlayer(log), new FakeScene(log));
|
|
var activator = new BlockingEngineActivator(
|
|
log,
|
|
engine,
|
|
activationStarted,
|
|
releaseActivation);
|
|
var session = new DynamicK3dSession(activator);
|
|
await using var dispatcher = new StaDispatcher(capacity: 1);
|
|
|
|
try
|
|
{
|
|
var connectTask = dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using (session)
|
|
{
|
|
session.Connect(options);
|
|
}
|
|
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None);
|
|
Assert.True(activationStarted.Wait(TimeSpan.FromSeconds(2)));
|
|
|
|
Assert.True(session.TryPreventKtapConnect());
|
|
releaseActivation.Set();
|
|
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => connectTask);
|
|
Assert.Equal(
|
|
PlayoutKtapConnectState.NotAttempted,
|
|
session.LastKtapConnectState);
|
|
Assert.DoesNotContain(log.Names, name =>
|
|
name.StartsWith("KTAPConnect:", StringComparison.Ordinal));
|
|
}
|
|
finally
|
|
{
|
|
releaseActivation.Set();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task Abandon_ReleasesEveryComReferenceWithoutDisconnect()
|
|
{
|
|
using var scenes = TemporarySceneDirectory.Create("test-scene.t2s");
|
|
var options = ValidatedPlayoutOptions.Create(TestOptions(scenes.Path));
|
|
var log = new FakeComLog();
|
|
var player = new FakePlayer(log);
|
|
var scene = new FakeScene(log);
|
|
var engine = new FakeEngine(log, player, scene);
|
|
var activator = new FakeActivator(log, engine);
|
|
var releaser = new FakeReleaser(
|
|
log,
|
|
(player, "Player"),
|
|
(engine, "Engine"),
|
|
(activator.EventHandler, "EventHandler"));
|
|
await using var dispatcher = new StaDispatcher(capacity: 1);
|
|
|
|
await dispatcher.InvokeAsync(
|
|
() =>
|
|
{
|
|
using var session = new DynamicK3dSession(activator, releaser);
|
|
session.Connect(options);
|
|
session.Abandon();
|
|
return true;
|
|
},
|
|
TimeSpan.FromSeconds(5),
|
|
CancellationToken.None);
|
|
|
|
Assert.DoesNotContain("Disconnect", log.Names);
|
|
Assert.Equal(1, log.Names.Count(name => name == "Release:Player"));
|
|
Assert.Equal(1, log.Names.Count(name => name == "Release:Engine"));
|
|
Assert.Equal(1, log.Names.Count(name => name == "Release:EventHandler"));
|
|
}
|
|
|
|
private static PlayoutOptions TestOptions(string sceneDirectory) => new()
|
|
{
|
|
Mode = PlayoutMode.Test,
|
|
SceneDirectory = sceneDirectory,
|
|
OutputChannel = 9,
|
|
TestProcessWindowTitlePattern = "^Tornado2 TEST$",
|
|
TestSceneAllowlist = ["test-scene"]
|
|
};
|
|
|
|
public sealed class FakeComLog
|
|
{
|
|
private readonly ConcurrentQueue<string> _names = new();
|
|
private readonly ConcurrentQueue<int> _threadIds = new();
|
|
private readonly ConcurrentQueue<ApartmentState> _apartmentStates = new();
|
|
|
|
public string[] Names => _names.ToArray();
|
|
|
|
public int[] ThreadIds => _threadIds.ToArray();
|
|
|
|
public ApartmentState[] ApartmentStates => _apartmentStates.ToArray();
|
|
|
|
public void Add(string name)
|
|
{
|
|
_names.Enqueue(name);
|
|
_threadIds.Enqueue(Environment.CurrentManagedThreadId);
|
|
_apartmentStates.Enqueue(Thread.CurrentThread.GetApartmentState());
|
|
}
|
|
}
|
|
|
|
private sealed class FakeActivator : ILateBoundComActivator
|
|
{
|
|
private readonly FakeComLog _log;
|
|
private readonly FakeEngine _engine;
|
|
private readonly object _eventHandler = new();
|
|
|
|
public FakeActivator(FakeComLog log, FakeEngine engine)
|
|
{
|
|
_log = log;
|
|
_engine = engine;
|
|
}
|
|
|
|
public object EventHandler => _eventHandler;
|
|
|
|
public object Create(Guid classId)
|
|
{
|
|
_log.Add($"Create:{classId:B}");
|
|
return classId switch
|
|
{
|
|
var value when value == K3dComConstants.KaEventHandlerClassGuid => _eventHandler,
|
|
var value when value == K3dComConstants.KaEngineClassGuid => _engine,
|
|
_ => throw new InvalidOperationException("Unexpected fake CLSID.")
|
|
};
|
|
}
|
|
}
|
|
|
|
private sealed class ThrowingActivator : ILateBoundComActivator
|
|
{
|
|
private readonly Exception _exception;
|
|
|
|
public ThrowingActivator(Exception exception)
|
|
{
|
|
_exception = exception;
|
|
}
|
|
|
|
public object Create(Guid classId) => throw _exception;
|
|
}
|
|
|
|
private sealed class BlockingEngineActivator : ILateBoundComActivator
|
|
{
|
|
private readonly FakeComLog _log;
|
|
private readonly FakeEngine _engine;
|
|
private readonly ManualResetEventSlim _activationStarted;
|
|
private readonly ManualResetEventSlim _releaseActivation;
|
|
private readonly object _eventHandler = new();
|
|
|
|
public BlockingEngineActivator(
|
|
FakeComLog log,
|
|
FakeEngine engine,
|
|
ManualResetEventSlim activationStarted,
|
|
ManualResetEventSlim releaseActivation)
|
|
{
|
|
_log = log;
|
|
_engine = engine;
|
|
_activationStarted = activationStarted;
|
|
_releaseActivation = releaseActivation;
|
|
}
|
|
|
|
public object Create(Guid classId)
|
|
{
|
|
_log.Add($"Create:{classId:B}");
|
|
if (classId == K3dComConstants.KaEventHandlerClassGuid)
|
|
{
|
|
return _eventHandler;
|
|
}
|
|
|
|
if (classId != K3dComConstants.KaEngineClassGuid)
|
|
{
|
|
throw new InvalidOperationException("Unexpected fake CLSID.");
|
|
}
|
|
|
|
_activationStarted.Set();
|
|
if (!_releaseActivation.Wait(TimeSpan.FromSeconds(5)))
|
|
{
|
|
throw new TimeoutException("fake activation coordination timeout");
|
|
}
|
|
|
|
return _engine;
|
|
}
|
|
}
|
|
|
|
public sealed class FakeEngine
|
|
{
|
|
private readonly FakeComLog _log;
|
|
private readonly FakePlayer _player;
|
|
private readonly FakeScene _scene;
|
|
private readonly int _connectResult;
|
|
private readonly Exception? _playerFailure;
|
|
private readonly Exception? _disconnectFailure;
|
|
private readonly Exception? _connectFailure;
|
|
|
|
public FakeEngine(
|
|
FakeComLog log,
|
|
FakePlayer player,
|
|
FakeScene scene,
|
|
int connectResult = 1,
|
|
Exception? playerFailure = null,
|
|
Exception? disconnectFailure = null,
|
|
Exception? connectFailure = null)
|
|
{
|
|
_log = log;
|
|
_player = player;
|
|
_scene = scene;
|
|
_connectResult = connectResult;
|
|
_playerFailure = playerFailure;
|
|
_disconnectFailure = disconnectFailure;
|
|
_connectFailure = connectFailure;
|
|
}
|
|
|
|
public int KTAPConnect(
|
|
int tcpMode,
|
|
string host,
|
|
int hostPort,
|
|
int clientPort,
|
|
object eventHandler)
|
|
{
|
|
Assert.NotNull(eventHandler);
|
|
_log.Add($"KTAPConnect:{tcpMode}:{host}:{hostPort}:{clientPort}");
|
|
if (_connectFailure is not null)
|
|
{
|
|
throw _connectFailure;
|
|
}
|
|
|
|
return _connectResult;
|
|
}
|
|
|
|
public object GetScenePlayerOnChannel(int channel)
|
|
{
|
|
_log.Add($"GetScenePlayerOnChannel:{channel}");
|
|
if (_playerFailure is not null)
|
|
{
|
|
throw _playerFailure;
|
|
}
|
|
|
|
return _player;
|
|
}
|
|
|
|
public object LoadScene(string sceneFile, string sceneName)
|
|
{
|
|
Assert.True(System.IO.Path.IsPathFullyQualified(sceneFile));
|
|
_log.Add($"LoadScene:{sceneName}");
|
|
return _scene;
|
|
}
|
|
|
|
public void BeginTransaction() => _log.Add("BeginTransaction");
|
|
|
|
public void EndTransaction() => _log.Add("EndTransaction");
|
|
|
|
public void Disconnect()
|
|
{
|
|
_log.Add("Disconnect");
|
|
if (_disconnectFailure is not null)
|
|
{
|
|
throw _disconnectFailure;
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class FakeReleaser : ILateBoundComObjectReleaser
|
|
{
|
|
private readonly FakeComLog _log;
|
|
private readonly (object Value, string Name)[] _objects;
|
|
|
|
public FakeReleaser(
|
|
FakeComLog log,
|
|
params (object Value, string Name)[] objects)
|
|
{
|
|
_log = log;
|
|
_objects = objects;
|
|
}
|
|
|
|
public void Release(object value)
|
|
{
|
|
var match = Assert.Single(_objects, item => ReferenceEquals(item.Value, value));
|
|
_log.Add($"Release:{match.Name}");
|
|
}
|
|
}
|
|
|
|
public sealed class FakePlayer
|
|
{
|
|
private readonly FakeComLog _log;
|
|
|
|
public FakePlayer(FakeComLog log)
|
|
{
|
|
_log = log;
|
|
}
|
|
|
|
public void Prepare(int layoutIndex, object scene)
|
|
{
|
|
Assert.NotNull(scene);
|
|
_log.Add($"Prepare:{layoutIndex}");
|
|
}
|
|
|
|
public void Play(int layoutIndex) => _log.Add($"Play:{layoutIndex}");
|
|
|
|
public void StopAll() => _log.Add("StopAll");
|
|
|
|
public void CutOut(int layoutIndex) => _log.Add($"CutOut:{layoutIndex}");
|
|
}
|
|
|
|
public sealed class FakeScene
|
|
{
|
|
private readonly FakeComLog _log;
|
|
|
|
public FakeScene(FakeComLog log)
|
|
{
|
|
_log = log;
|
|
}
|
|
|
|
public void SetSceneEffectType(int layoutIndex, int effectType, int duration) =>
|
|
_log.Add($"SetSceneEffectType:{layoutIndex}:{effectType}:{duration}");
|
|
|
|
public object GetObject(string objectName)
|
|
{
|
|
_log.Add($"GetObject:{objectName}");
|
|
return new FakeSceneObject(_log, objectName);
|
|
}
|
|
|
|
public void QueryVariables() => _log.Add("QueryVariables");
|
|
}
|
|
|
|
public sealed class FakeSceneObject
|
|
{
|
|
private readonly FakeComLog _log;
|
|
private readonly string _name;
|
|
|
|
public FakeSceneObject(FakeComLog log, string name)
|
|
{
|
|
_log = log;
|
|
_name = name;
|
|
}
|
|
|
|
public void SetValue(string value) => _log.Add($"SetValue:{_name}:{value}");
|
|
|
|
public void SetVisible(int visible) => _log.Add($"SetVisible:{_name}:{visible}");
|
|
}
|
|
}
|