public void TestShopUndo()
{
TestReceiver tr = new TestReceiver(1, 1);
Shop shop = new Shop(tr);
Assert.IsFalse(shop.Undo());
Assert.IsFalse(shop.Redo());
shop.addToSell(new Item(0, "HP low", PotionType.health, 15));
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
shop.addToCart(new Item(0, "BF", PotionType.buff, 75));
shop.addToSell(new Item(0, "DMG low", PotionType.buff, 20));
shop.addToSell(new Item(0, "DMG low", PotionType.damage, 20));
shop.addToCart(new Item(0, "BF", PotionType.buff, 75));
Assert.IsTrue(shop.Undo());
Assert.IsTrue(shop.Undo());
Assert.IsTrue(shop.Undo());
Assert.IsTrue(shop.Undo());
shop.execute();
Assert.IsFalse(shop.Undo());
Assert.IsFalse(shop.Redo());
tr.SetExpectedValues(0, 0);
shop.execute();
Assert.IsFalse(shop.Undo());
Assert.IsFalse(shop.Redo());
}
public void DisposeTest()
{
Func <TestReceiverOptions, IReceiver> createReceiver = options =>
{
return(new TestReceiver("MyTestReceiver", options.TestSetting1, options.TestSetting2));
};
var initialOptions = new TestReceiverOptions
{
TestSetting1 = "InitialTestSetting1",
TestSetting2 = "InitialTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestReceiverOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>();
mockOptionsMonitor.Setup(m => m.Get("MyReloadingReceiver")).Returns(initialOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestReceiverOptions, string> >()))
.Returns(mockChangeListener.Object);
Action <TestReceiverOptions> configureOptions = options => { };
IReceiver receiver = ReloadingReceiver.New("MyReloadingReceiver",
createReceiver, mockOptionsMonitor.Object, configureOptions);
TestReceiver testReceiver = ((dynamic)receiver).Receiver;
testReceiver.Disposed.Should().BeFalse();
mockChangeListener.Verify(m => m.Dispose(), Times.Never());
receiver.Dispose();
testReceiver.Disposed.Should().BeTrue();
mockChangeListener.Verify(m => m.Dispose());
}
public void TestShopRedoAfterRedoAndNewState()
{
TestReceiver tr = new TestReceiver(2, 2);
Shop shop = new Shop(tr);
shop.addToSell(new Item(0, "HP low", PotionType.health, 15));
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
shop.addToSell(new Item(0, "HP low", PotionType.health, 15));
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
shop.addToSell(new Item(0, "HP low", PotionType.health, 15));
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
Assert.IsTrue(shop.Undo());
Assert.IsTrue(shop.Undo());
Assert.IsTrue(shop.Undo());
Assert.IsTrue(shop.Redo());
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
Assert.IsFalse(shop.Redo());
shop.execute();
Assert.IsFalse(shop.Undo());
Assert.IsFalse(shop.Redo());
tr.SetExpectedValues(0, 0);
shop.execute();
Assert.IsFalse(shop.Undo());
Assert.IsFalse(shop.Redo());
}
public void T00_ResumeEmpty()
{
T00_LogInit();
IRegionManager rmgr = new RegionExposedFiles(InitMode.NEW_REGION, "c:\\BENDtst\\1");
TestReceiver receiver = new TestReceiver();
LogWriter lr = LogWriter.LogWriter_Resume(rmgr, receiver);
Assert.AreEqual(receiver.cmds.Count, 0, "there should be no log records");
}
public void TestShopEmpty()
{
TestReceiver tr = new TestReceiver(0, 0);
Shop shop = new Shop(tr);
shop.execute();
tr.SetExpectedValues(0, 0);
shop.execute();
}
public void ThrowIfNoHandlers()
{
var handler = new NoHandlersResolver();
var storage = new GlobalStorage(handler);
var receiver = new TestReceiver();
var e = Assert.Throws <Exception>(() => storage.On().Add(receiver));
Assert.AreEqual("Can't bind method TestReceiver to global: No methods matched signature", e.Message);
}
public void DynamicDispose()
{
var receiver = new TestReceiver();
Storage.On <TestEntity>().Add(receiver);
Assert.AreEqual(2, Storage.On <TestEntity>().Count);
Storage.On <TestEntity>().Dispose();
Assert.AreEqual(0, Storage.On <TestEntity>().Count);
}
public void TestShopSelling()
{
TestReceiver tr = new TestReceiver(0, 2);
Shop shop = new Shop(tr);
shop.addToSell(new Item(0, "BF low", PotionType.buff, 10));
shop.addToSell(new Item(0, "DMG low", PotionType.damage, 20));
shop.execute();
tr.SetExpectedValues(0, 0);
shop.execute();
}
public void DisposeEntity()
{
var receiver = new TestReceiver();
var entity = new TestEntity();
Storage.On(entity).Add(receiver);
Assert.AreEqual(2, Storage.On(entity).Count);
Storage.On(entity).Dispose();
Assert.AreEqual(0, Storage.On(entity).Count);
}
public void TestShopBuying()
{
TestReceiver tr = new TestReceiver(4, 0);
Shop shop = new Shop(tr);
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
shop.addToCart(new Item(0, "BF", PotionType.buff, 75));
shop.addToCart(new Item(0, "DMG", PotionType.damage, 63));
shop.addToCart(new Item(0, "BF2", PotionType.buff, 42));
shop.execute();
tr.SetExpectedValues(0, 0);
shop.execute();
}
public void TestTwoParameterCommand()
{
TestReceiver receiver1 = new TestReceiver();
ICommand testMessageOutputCommand = new
DelegateCommand<string, string>(receiver1.ReceiverAction, "hello", "yunyun");
using (var writer = new StringWriter())
{
Console.SetOut(writer);
testMessageOutputCommand.Execute();
Assert.AreEqual("hellois that working yunyun" + Environment.NewLine, writer.ToString());
}
}
public void TestShopSellingAndBuying()
{
TestReceiver tr = new TestReceiver(2, 3);
Shop shop = new Shop(tr);
shop.addToCart(new Item(0, "HP", PotionType.health, 50));
shop.addToCart(new Item(0, "BF", PotionType.buff, 75));
shop.addToSell(new Item(0, "HP low", PotionType.health, 15));
shop.addToSell(new Item(0, "BF low", PotionType.buff, 10));
shop.addToSell(new Item(0, "DMG low", PotionType.damage, 20));
shop.execute();
tr.SetExpectedValues(0, 0);
shop.execute();
}
public void GlobalStorage()
{
var handler = new MockHandlerResolver(new[] {
new HandlerMeta(null, typeof(int), 2,
EfficientInvoker.ForMethod(typeof(TestReceiver), "HandleSignal"))
});
var es = new GlobalStorage(handler);
RunMeasure(() => {
var receiver = new TestReceiver();
es.On().Add(receiver);
es.On().Send(1);
es.On().Remove(receiver);
});
}
public void ExpectedExecutionTimeTwoSubOneSource()
{
var receiver = new TestReceiver();
var source = new TestSource();
source.Event += (receiver.ReceiveEvent);
source.Event += (receiver.ReceiveEvent);
var start = DateTime.Now;
source.RaiseEvent(this, EventArgs.Empty);
var elapsed = DateTime.Now - start;
Assert.That(elapsed, Is.GreaterThanOrEqualTo(TimeSpan.FromMilliseconds(1950)));
Assert.That(elapsed, Is.LessThanOrEqualTo(TimeSpan.FromMilliseconds(2050)));
}
public void ConstructorTest()
{
Func <TestReceiverOptions, IReceiver> expectedCreateReceiver = options =>
{
return(new TestReceiver("MyTestReceiver", options.TestSetting1, options.TestSetting2));
};
var testOptions = new TestReceiverOptions
{
TestSetting1 = "MyTestSetting1",
TestSetting2 = "MyTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestReceiverOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>(MockBehavior.Strict);
mockOptionsMonitor.Setup(m => m.Get("MyReloadingReceiver")).Returns(testOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestReceiverOptions, string> >()))
.Returns(mockChangeListener.Object);
Action <TestReceiverOptions> expectedConfigureOptions = options => { };
IReceiver receiver = ReloadingReceiver.New("MyReloadingReceiver",
expectedCreateReceiver, mockOptionsMonitor.Object, expectedConfigureOptions);
receiver.Name.Should().Be("MyReloadingReceiver");
receiver.GetType().Should().Be(ReloadingReceiver);
dynamic r = receiver;
Func <TestReceiverOptions, IReceiver> createReceiver = r.CreateReceiver;
createReceiver.Should().BeSameAs(expectedCreateReceiver);
Action <TestReceiverOptions> configureOptions = r.ConfigureOptions;
configureOptions.Should().BeSameAs(expectedConfigureOptions);
TestReceiver testReceiver = r.Receiver;
testReceiver.Name.Should().Be("MyTestReceiver");
testReceiver.TestSetting1.Should().Be("MyTestSetting1");
testReceiver.TestSetting2.Should().Be("MyTestSetting2");
IDisposable changeListener = r.ChangeListener;
changeListener.Should().BeSameAs(mockChangeListener.Object);
}
public void ReceiverObject()
{
var receiver = new TestReceiver();
var entity = new TestEntity();
Storage.On(entity).Add(receiver);
Assert.AreEqual(2, Storage.On(entity).Count);
Storage.On(entity).Send(1);
Storage.On(entity).Send('t');
receiver.Verify("IntReceive", 1);
receiver.Verify("CharReceive", entity, 't');
Storage.On(entity).Remove(receiver);
Assert.AreEqual(0, Storage.On(entity).Count);
}
/// <summary>
/// This is the equivalent of "RunAll" functionality
/// </summary>
/// <param name="sources">Refers to the list of test sources passed to the test adapter from the client. (Client could be VS or command line)</param>
/// <param name="runContext">Defines the settings related to the current run</param>
/// <param name="frameworkHandle">Handle to framework. Used for recording results</param>
public void RunTests(IEnumerable <string> sources, ITestDiscoverer discoverer)
{
ValidateArg.NotNull(sources, nameof(sources));
ValidateArg.NotNull(discoverer, nameof(discoverer));
var receiver = new TestReceiver();
discoverer.DiscoverTests(sources, /*discoveryContext*/ null, this.frameworkHandle, receiver);
if (this.cancelRequested.WaitOne(0))
{
return;
}
this.RunTests(receiver.Tests);
}
public async Task VerifyAwaitedInvocation()
{
var receiver = new TestReceiver();
var source = new TestSource();
source.Event += receiver.ReceiveEvent;
source.Event += receiver.ReceiveEvent;
var start = DateTime.Now;
await source.RaiseEvent(this, EventArgs.Empty);
var elapsed = DateTime.Now - start;
Assert.That(elapsed, Is.GreaterThanOrEqualTo(TimeSpan.FromMilliseconds(1000)));
Assert.That(elapsed, Is.LessThanOrEqualTo(TimeSpan.FromMilliseconds(1150)));
Assert.That(receiver.CallCount, Is.EqualTo(2));
}
public void DynamicEntityStorage()
{
var handler = new MockHandlerResolver(new[] {
new HandlerMeta(typeof(TestEntity), typeof(int), 2,
EfficientInvoker.ForMethod(typeof(TestReceiver), "HandleSignal"))
});
var es = new DynamicStorage(handler);
var entity = new TestEntity();
RunMeasure(() => {
var receiver = new TestReceiver();
es.On <TestEntity>().Add(receiver);
es.On(entity).Send(1);
es.On <TestEntity>().Remove(receiver);
});
}
public void OnOptionsChangedTest2()
{
Func <TestReceiverOptions, IReceiver> createReceiver = options =>
{
return(new TestReceiver("MyTestReceiver", options.TestSetting1, options.TestSetting2));
};
var initialOptions = new TestReceiverOptions
{
TestSetting1 = "InitialTestSetting1",
TestSetting2 = "InitialTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestReceiverOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>(MockBehavior.Strict);
Action <TestReceiverOptions, string> onChangeCallback = null;
mockOptionsMonitor.Setup(m => m.Get("MyReloadingReceiver")).Returns(initialOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestReceiverOptions, string> >()))
.Callback <Action <TestReceiverOptions, string> >(onChange => onChangeCallback = onChange)
.Returns(mockChangeListener.Object);
Action <TestReceiverOptions> configureOptions = options => { };
IReceiver receiver = ReloadingReceiver.New("MyReloadingReceiver",
createReceiver, mockOptionsMonitor.Object, configureOptions);
dynamic r = receiver;
onChangeCallback.Should().NotBeNull();
TestReceiver initialTestReceiver = r.Receiver;
var newOptions = new TestReceiverOptions
{
TestSetting1 = "NewTestSetting1",
TestSetting2 = "NewTestSetting2"
};
// Simulate a change to some other receiver:
onChangeCallback(newOptions, "SomeOtherReceiver");
TestReceiver newTestReceiver = r.Receiver;
newTestReceiver.Should().BeSameAs(initialTestReceiver);
initialTestReceiver.Disposed.Should().BeFalse();
}
public void SubscribeNullUriWithReceiverTest()
{
ArgumentNullException expected = null;
TestReceiver receiver = new TestReceiver();
Uri uri = null;
try
{
FeedEngine.Subscribe(uri, receiver);
}
catch (ArgumentNullException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
public void SubscribeNullReceiverTest()
{
ArgumentNullException expected = null;
TestReceiver receiver = null;
Uri uri = new Uri("http://blog.opennetcf.com");
try
{
FeedEngine.Subscribe(uri, receiver);
}
catch (ArgumentNullException ex)
{
expected = ex;
}
Assert.IsNotNull(expected);
}
public Task VerifyNonAwaitedInvocation()
{
var receiver = new TestReceiver();
var source = new TestSource();
source.Event += (receiver.ReceiveEvent);
source.Event += (receiver.ReceiveEvent);
var start = DateTime.Now;
source.RaiseEvent(this, EventArgs.Empty);
var elapsed = DateTime.Now - start;
Assert.That(receiver.CallCount, Is.EqualTo(0));
Assert.That(elapsed, Is.LessThanOrEqualTo(TimeSpan.FromMilliseconds(100)));
return(System.Threading.Tasks.Task.CompletedTask);
}
/// <summary>
/// This is the equivallent of "RunAll" functionality
/// </summary>
/// <param name="sources">Refers to the list of test sources passed to the test adapter from the client. (Client could be VS or command line)</param>
/// <param name="runContext">Defines the settings related to the current run</param>
/// <param name="frameworkHandle">Handle to framework. Used for recording results</param>
public void RunTests(IEnumerable<string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle) {
ValidateArg.NotNull(sources, "sources");
ValidateArg.NotNull(runContext, "runContext");
ValidateArg.NotNull(frameworkHandle, "frameworkHandle");
_cancelRequested.Reset();
var receiver = new TestReceiver();
var discoverer = new TestDiscoverer();
discoverer.DiscoverTests(sources, null, frameworkHandle, receiver);
if (_cancelRequested.WaitOne(0)) {
return;
}
RunTestCases(receiver.Tests, runContext, frameworkHandle);
}
public void ProcessReceiverClass()
{
var es = new EntitySignals();
var entity = Object.Instantiate(new GameObject());
var receiver = new TestReceiver();
es.On(entity).Add(receiver);
Assert.AreEqual(2, es.On(entity).Count);
es.On(entity).Send(1);
es.On(entity).Send('t');
es.On(entity).Remove(receiver);
Assert.AreEqual(0, es.On(entity).Count);
receiver.Verify("First", entity, 1);
receiver.Verify("Second", 't');
}
//TODO シリアル用テストケースは追加必要。CygwinはTelnetと同じなのでまあいいだろう
//TODO ITerminalOutputのテスト。正しく送信されたかを確認するのは難しい感じもするが
//TODO Reproduceサポートの後、SSH2で1Connection-複数Channelを開き、個別に開閉してみる
private ITerminalConnection CreateTelnetConnection()
{
ITCPParameter tcp = _protocolService.CreateDefaultTelnetParameter();
tcp.Destination = UnitTestUtil.GetUnitTestConfig("protocols.telnet_connectable");
Debug.Assert(tcp.Port == 23);
ISynchronizedConnector sc = _protocolService.CreateFormBasedSynchronozedConnector(null);
IInterruptable t = _protocolService.AsyncTelnetConnect(sc.InterruptableConnectorClient, tcp);
ITerminalConnection con = sc.WaitConnection(t, 5000);
//Assert.ReferenceEquals(con.Destination, tcp); //なぜか成立しない
Debug.Assert(con.Destination == tcp);
_rawsocket = ((InterruptableConnector)t).RawSocket;
_testReceiver = new TestReceiver();
con.Socket.RepeatAsyncRead(_testReceiver);
return(con);
}
public void ProcessReceiverClassMethods()
{
var es = new EntitySignals();
var entity = Object.Instantiate(new GameObject());
var receiver = new TestReceiver();
es.On(entity).Add((ESHandler <GameObject, int>)receiver.OnGameObjectSignal);
es.On(entity).Add((ESHandler <char>)receiver.OnGameObjectSignal);
Assert.AreEqual(2, es.On(entity).Count);
es.On(entity).Send(1);
es.On(entity).Send('t');
es.On(entity).Dispose();
Assert.AreEqual(0, es.On(entity).Count);
receiver.Verify("First", entity, 1);
receiver.Verify("Second", 't');
}
public void RunTests(IEnumerable <string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle)
{
ValidateArg.NotNull(sources, "sources");
ValidateArg.NotNull(runContext, "runContext");
ValidateArg.NotNull(frameworkHandle, "frameworkHandle");
_cancelRequested.Reset();
var receiver = new TestReceiver();
TestDiscoverer.DiscoverTests(sources, frameworkHandle, receiver, runContext.RunSettings);
if (_cancelRequested.WaitOne(0))
{
return;
}
RunTestCases(receiver.Tests, runContext, frameworkHandle);
}
public void ReceiverMethodReference()
{
var receiver = new TestReceiver();
var entity = new TestEntity();
var delegateA = new ESHandler <int>(receiver.IntReceive);
var delegateB = new ESHandler <TestEntity, char>(receiver.CharReceive);
Storage.On(entity).Add(delegateA);
Storage.On(entity).Add(delegateB);
Assert.AreEqual(2, Storage.On(entity).Count);
Storage.On(entity).Send(1);
Storage.On(entity).Send('t');
receiver.Verify("IntReceive", 1);
receiver.Verify("CharReceive", entity, 't');
Storage.On(entity).Remove(delegateA);
Storage.On(entity).Remove(delegateB);
Assert.AreEqual(0, Storage.On(entity).Count);
}
private ITerminalConnection CreateSSHConnection(SSHProtocol sshprotocol)
{
ISSHLoginParameter ssh = _protocolService.CreateDefaultSSHParameter();
ssh.Method = sshprotocol;
ssh.Account = UnitTestUtil.GetUnitTestConfig("protocols.ssh_account");
ssh.PasswordOrPassphrase = UnitTestUtil.GetUnitTestConfig("protocols.ssh_password");
ITCPParameter tcp = (ITCPParameter)ssh.GetAdapter(typeof(ITCPParameter));
tcp.Destination = UnitTestUtil.GetUnitTestConfig("protocols.ssh_connectable");
Debug.Assert(tcp.Port == 22);
ISynchronizedConnector sc = _protocolService.CreateFormBasedSynchronozedConnector(null);
IInterruptable t = _protocolService.AsyncSSHConnect(sc.InterruptableConnectorClient, ssh);
ITerminalConnection con = sc.WaitConnection(t, 5000);
Debug.Assert(con.Destination == ssh);
_rawsocket = ((InterruptableConnector)t).RawSocket;
_testReceiver = new TestReceiver();
con.Socket.RepeatAsyncRead(_testReceiver);
return(con);
}
/// <summary>
/// The init.
/// </summary>
private void Init()
{
//LocalBroadcastManager localBM = LocalBroadcastManager.GetInstance(this);
_receiver = new TestReceiver();
etTextTime = FindViewById <EditText>(Resource.Id.etTextTime);
Button btnRegisterBroadcast = FindViewById <Button>(Resource.Id.btnRegisterBroadcast);
btnRegisterBroadcast.Click += (send, e) =>
{
};
Button btnUnRegisterBroadcast = FindViewById <Button>(Resource.Id.btnUnRegisterBroadcast);
btnUnRegisterBroadcast.Click += (send, e) =>
{
};
Button btnStartServce = FindViewById <Button>(Resource.Id.btnStartServce);
btnStartServce.Click += (send, e) =>
{
};
Button btnStopService = FindViewById <Button>(Resource.Id.btnStopService);
btnStopService.Click += (send, e) => { };
//
Button btnStartAlarm = FindViewById <Button>(Resource.Id.btnStartAlarm);
btnStartAlarm.Click += BtnStartAlarm_Click;
//
Button btnStopAlarm = FindViewById <Button>(Resource.Id.btnStopAlarm);
btnStopAlarm.Click += BtnStopAlarm_Click;
//
Button btnTest = FindViewById <Button>(Resource.Id.btnTest);
btnTest.Click += BtnTest_Click;
}
public void ProcessReceiverClass()
{
var receiver = new TestReceiver();
var resolver = new InterfaceHandlersResolver();
var results = resolver.GetHandlers(typeof(TestReceiver));
Assert.AreEqual(2, results.Length);
var intHandler = results.First(m => m.SignalType == typeof(int));
Assert.AreEqual(2, intHandler.ParamCount);
Assert.AreEqual(typeof(string), intHandler.RequiredType);
intHandler.MethodInvoker.Invoke(receiver, "entity", 1);
receiver.Verify("Int", "entity", 1);
var charHandler = results.First(m => m.SignalType == typeof(char));
Assert.AreEqual(2, charHandler.ParamCount);
Assert.AreEqual(typeof(string), charHandler.RequiredType);
charHandler.MethodInvoker.Invoke(receiver, "entity", 't');
receiver.Verify("Char", "entity", 't');
}
public void SendAfterGarbageCollectTest()
{
var messenger = Messenger.CreateInstance();
var obj = new TestReceiver();
messenger.Register <TestMessage>(obj, obj.HandleMessage);
messenger.Send(new TestMessage());
Assert.True(obj.MsgHandled);
obj.MsgHandled = false;
var weakRef = new WeakReference(obj);
// ReSharper disable once RedundantAssignment
obj = null;
CollectGarbage();
messenger.Send(new TestMessage());
//Xunit.Assert.False(weakRef.IsAlive);
}
public void T01_LogCheckpoint()
{
IRegionManager rmgr = new RegionExposedFiles(InitMode.NEW_REGION, "c:\\BENDtst\\2");
byte[] cmddata = { 0x81, 0x82, 0x83 };
long logWaitNumber;
{
// make a new empty log
TestReceiver receiver = new TestReceiver();
int system_reserved_space;
LogWriter lr = LogWriter.LogWriter_NewRegion(rmgr, receiver, out system_reserved_space);
lr.log_handler.setDebugLogSegments(); // force one command per log segment
// find out how many empty segments there are...
int emptySegments = lr.log_handler.emptyLogSegments;
// add a command to fill up the log segments..
for (int i = 0; i < emptySegments; i++) {
lr.addCommand(LogCommands.UPDATE, cmddata, out logWaitNumber);
lr.flushPendingCommandsThrough(logWaitNumber);
printLogStatus(lr, String.Format("filling empty segments {0}",i));
}
Assert.AreEqual(1, lr.log_handler.emptyLogSegments, "should be no empty log segments");
printLogStatus(lr, "log almost full");
// now checkpoint the log
lr.checkpointStart();
lr.checkpointDrop(out logWaitNumber);
lr.flushPendingCommandsThrough(logWaitNumber);
Assert.LessOrEqual(2, lr.log_handler.activeLogSegments, "should have only <= 2 active log segments");
printLogStatus(lr, "log checkpoint complete");
lr.Dispose();
}
}
public void T02_LogCheckpointResumeOrder()
{
IRegionManager rmgr = new RegionExposedFiles(InitMode.NEW_REGION, "c:\\BENDtst\\2");
byte[] cmddata = { 0x00 };
int timestamp = 5;
long logWaitNumber;
{
// make a new empty log
TestReceiver receiver = new TestReceiver();
int system_reserved_space;
LogWriter lr = LogWriter.LogWriter_NewRegion(rmgr, receiver, out system_reserved_space);
lr.log_handler.setDebugLogSegments(); // force one command per log segment
// find out how many empty segments there are...
// (1) add commands to fill up the log segments..
{
int emptySegments = lr.log_handler.emptyLogSegments;
for (int i = 0; i < emptySegments; i++) {
cmddata[0] = (byte)timestamp;
timestamp++;
lr.addCommand(LogCommands.UPDATE, cmddata, out logWaitNumber);
lr.flushPendingCommandsThrough(logWaitNumber);
printLogStatus(lr, String.Format("filling empty segments {0}", i));
}
Assert.AreEqual(1, lr.log_handler.emptyLogSegments, "should be no empty log segments 1");
printLogStatus(lr, "log almost full");
}
// (2) checkpoint the log
{
lr.checkpointStart();
lr.checkpointDrop(out logWaitNumber);
lr.flushPendingCommandsThrough(logWaitNumber);
Assert.LessOrEqual(1, lr.log_handler.activeLogSegments, "should have only <= 2 active log segments");
printLogStatus(lr, "log checkpoint complete");
}
// (3) add commands to fill newly free log segments
{
int emptySegments = lr.log_handler.emptyLogSegments;
for (int i = 0; i < emptySegments; i++) {
cmddata[0] = (byte)timestamp;
timestamp++;
lr.addCommand(LogCommands.UPDATE, cmddata, out logWaitNumber);
lr.flushPendingCommandsThrough(logWaitNumber);
printLogStatus(lr, String.Format("filling empty segments {0}", i));
}
Assert.LessOrEqual(lr.log_handler.emptyLogSegments, 1, "should be no empty log segments 2");
printLogStatus(lr, "log almost full 2");
}
// (4) shutdown
lr.Dispose();
}
// (5) now resume, make sure we resume in order
{
TestReceiver receiver = new TestReceiver();
LogWriter lr = LogWriter.LogWriter_Resume(rmgr, receiver);
int cur = 0;
foreach (var cmd in receiver.cmds) {
if (cmd.cmd == LogCommands.UPDATE) {
Console.WriteLine("Resume Record : {0} {1}", cmd.cmd.ToString(), cmd.cmddata[0]);
Assert.Greater(cmd.cmddata[0], cur, "order should be increasing");
cur = cmd.cmddata[0];
} else {
Console.WriteLine("empty command : {0}", cmd.cmd.ToString());
}
}
}
}
public void T00_ResumeWithRecords()
{
IRegionManager rmgr = new RegionExposedFiles(InitMode.NEW_REGION, "c:\\BENDtst\\2");
byte[] cmddata = { 0x81, 0x82, 0x83 };
const int NUM_COMMANDS = 3;
// make a new empty log
{
int system_reserved_space;
LogWriter lr = LogWriter.LogWriter_NewRegion(rmgr, new DummyLogReceiver(), out system_reserved_space);
lr.log_handler.setDebugLogSegments();
Assert.AreEqual(1, lr.log_handler.activeLogSegments, "one active log segment");
// add NUM_COMMANDS records to the log
long logWaitNumber;
for (int i=0;i<NUM_COMMANDS;i++) {
lr.addCommand(LogCommands.UPDATE, cmddata, out logWaitNumber);
lr.flushPendingCommands();
printLogStatus(lr, String.Format("addCommand iteration {0}", i));
}
lr.Dispose();
}
// reinit and resume from the log
{
TestReceiver receiver = new TestReceiver();
LogWriter lr = LogWriter.LogWriter_Resume(rmgr, receiver);
Assert.AreEqual(NUM_COMMANDS, lr.log_handler.activeLogSegments, "should be NUM_COMMANDS log segments");
Assert.AreEqual(NUM_COMMANDS, receiver.cmds.Count, "number of log records incorrect");
Assert.AreEqual(LogCommands.UPDATE, receiver.cmds[0].cmd, "cmdbyte should match");
Assert.AreEqual(cmddata, receiver.cmds[0].cmddata, "cmddata should match");
lr.Dispose();
}
// assert the log had the records
}
public void T01_OverflowLog()
{
IRegionManager rmgr = new RegionExposedFiles(InitMode.NEW_REGION, "c:\\BENDtst\\2");
byte[] cmddata = { 0x00 };
{
// make a new empty log
TestReceiver receiver = new TestReceiver();
int system_reserved_space;
LogWriter lr = LogWriter.LogWriter_NewRegion(rmgr, receiver, out system_reserved_space);
lr.log_handler.setDebugLogSegments(); // force one command per log segment
// find out how many empty segments there are...
int emptySegments = lr.log_handler.emptyLogSegments;
// add a command to fill up the log segments..
long logWaitNumber = 0;
for (int i = 0; i <= emptySegments; i++) {
lr.addCommand(LogCommands.UPDATE, cmddata, out logWaitNumber);
lr.flushPendingCommands();
}
Assert.AreEqual(0, lr.log_handler.emptyLogSegments, "should be no empty log segments");
// now add another command.. which should overflow the log segments and send us the log-extend request
// make sure a write attempt blocks (or fails)
// make sure a log-extend still succeeds.
Assert.Fail("INTENTIONAL FAIL - test not fully implemented");
lr.Dispose();
}
}
private ITerminalConnection CreateSSHConnection(SSHProtocol sshprotocol) {
ISSHLoginParameter ssh = _protocolService.CreateDefaultSSHParameter();
ssh.Method = sshprotocol;
ssh.Account = UnitTestUtil.GetUnitTestConfig("protocols.ssh_account");
ssh.PasswordOrPassphrase = UnitTestUtil.GetUnitTestConfig("protocols.ssh_password");
ITCPParameter tcp = (ITCPParameter)ssh.GetAdapter(typeof(ITCPParameter));
tcp.Destination = UnitTestUtil.GetUnitTestConfig("protocols.ssh_connectable");
Debug.Assert(tcp.Port==22);
ISynchronizedConnector sc = _protocolService.CreateFormBasedSynchronozedConnector(null);
IInterruptable t = _protocolService.AsyncSSHConnect(sc.InterruptableConnectorClient, ssh);
ITerminalConnection con = sc.WaitConnection(t, 5000);
Debug.Assert(con.Destination==ssh);
_rawsocket = ((InterruptableConnector)t).RawSocket;
_testReceiver = new TestReceiver();
con.Socket.RepeatAsyncRead(_testReceiver);
return con;
}
//TODO シリアル用テストケースは追加必要。CygwinはTelnetと同じなのでまあいいだろう
//TODO ITerminalOutputのテスト。正しく送信されたかを確認するのは難しい感じもするが
//TODO Reproduceサポートの後、SSH2で1Connection-複数Channelを開き、個別に開閉してみる
private ITerminalConnection CreateTelnetConnection() {
ITCPParameter tcp = _protocolService.CreateDefaultTelnetParameter();
tcp.Destination = UnitTestUtil.GetUnitTestConfig("protocols.telnet_connectable");
Debug.Assert(tcp.Port==23);
ISynchronizedConnector sc = _protocolService.CreateFormBasedSynchronozedConnector(null);
IInterruptable t = _protocolService.AsyncTelnetConnect(sc.InterruptableConnectorClient, tcp);
ITerminalConnection con = sc.WaitConnection(t, 5000);
//Assert.ReferenceEquals(con.Destination, tcp); //なぜか成立しない
Debug.Assert(con.Destination==tcp);
_rawsocket = ((InterruptableConnector)t).RawSocket;
_testReceiver = new TestReceiver();
con.Socket.RepeatAsyncRead(_testReceiver);
return con;
}
