public void Now_should_throw_when_called_directly()
{
var raiser = new Raise<EventArgs>(null, EventArgs.Empty);
Assert.Throws<NotSupportedException>(() =>
raiser.Now(null, null));
}
public void Now_should_throw_when_called_directly()
{
// Arrange
var raiser = new Raise<EventArgs>(null, EventArgs.Empty);
// Act
var exception = Record.Exception(() => raiser.Now(null, null));
// Assert
exception.Should().BeAnExceptionOfType<NotSupportedException>();
}
public void Test()
{
var timeProvider = CoroutineSystemTestUtil.TestTimeProvider();
_coroutineManager = new CoroutineManager();
_coroutineManager.TimeProvider = timeProvider;
_coroutineManager.StartCoroutine(this, AddEnumerator());
timeProvider.OnUpdate += Raise.Event <Action>();
timeProvider.OnUpdate += Raise.Event <Action>();
timeProvider.OnUpdate += Raise.Event <Action>();
timeProvider.OnUpdate += Raise.Event <Action>();
timeProvider.OnUpdate += Raise.Event <Action>();
Assert.IsTrue(_firstFlag);
Assert.AreEqual(_secondFlag, 1);
Assert.AreEqual(_thirdFlag, 1);
}
public void RfidDetected_PresentsRfidWithMatchingId_StateChangeToAvailable(int rfid)
{
//ARRANGE
UUT.State = PhoneLockerState.Locked;
fakeChargeControl.Connected = true;
UUT.oldId = rfid; //gammelt id fra da man låste skabet
//ACT
fakeRfidReader.RFIDDetectedEvent += Raise.EventWith(new RFIDDetectedEventArgs()
{
RFID = rfid
});
PhoneLockerState desiredState = PhoneLockerState.Available;
//ASSERT
Assert.That(UUT.State, Is.EqualTo(desiredState));
}
public void Should_not_leak_handlers_when_raising()
{
// Arrange
var eventHandlerArgumentProvider = ServiceLocator.Current.Resolve <EventHandlerArgumentProviderMap>();
this.foo = A.Fake <IFoo>();
this.foo.SomethingHappened += this.Foo_SomethingHappened;
EventHandler raisingHandler = Raise.WithEmpty(); // EventHandler to force the implicit conversion
// Act
this.foo.SomethingHappened += raisingHandler;
// Assert
IEventRaiserArgumentProvider ignoredArgumentProvider;
eventHandlerArgumentProvider.TryTakeArgumentProviderFor(raisingHandler, out ignoredArgumentProvider)
.Should().BeFalse();
}
public void Raise_PropertyChanged_If_Played()
{
var ctx = new CreationContext();
var sut = ctx.Create();
sut.Position = 0;
sut.Duration = 100;
using (var monitor = sut.Monitor())
{
ctx.Player.Events.PlayerPlaying += Raise.Event();
monitor.Should().RaisePropertyChangeFor(x => x.IsPaused);
monitor.Should().RaisePropertyChangeFor(x => x.IsStopped);
monitor.Should().RaisePropertyChangeFor(x => x.CanPause);
monitor.Should().RaisePropertyChangeFor(x => x.CanStop);
monitor.Should().RaisePropertyChangeFor(x => x.CanPause);
}
}
public void Write_WhenPhoneLockerIsAvailableChargerConnectedRfidDetected_TimeAndRFIDCorrectLogged(int rfid)
{
//ARRANGE
UUT.State = PhoneLockerState.Available;
fakeChargeControl.Connected = true;
string message2write = DateTime.Now.ToString("HH:mm:ss") + ": Skab laast med RFID: " + rfid;
UUT.Rfid = rfid;
//ACT
fakeRfidReader.RFIDDetectedEvent += Raise.EventWith(new RFIDDetectedEventArgs()
{
RFID = rfid
});
//ASSERT
fakeLogging.Received(1).Write(message2write);
}
public void initializes_pendingValidators_from_db()
{
var blockNumber = 10;
var validators = TestItem.Addresses.Take(10).ToArray();
var blockHash = Keccak.Compute("Test");
var pendingValidators = new ContractValidator.PendingValidators(blockNumber, blockHash, validators);
var rlp = Rlp.Encode(pendingValidators);
_db[ContractValidator.PendingValidatorsKey.Bytes].Returns(rlp.Bytes);
IAuRaValidatorProcessor validator = new ContractValidator(_validator, _db, _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _logManager, 1);
validator.SetFinalizationManager(_blockFinalizationManager);
_blockFinalizationManager.BlocksFinalized +=
Raise.EventWith(new FinalizeEventArgs(_block.Header,
Build.A.BlockHeader.WithNumber(blockNumber).WithHash(blockHash).TestObject));
validators.Select(v => validator.IsValidSealer(v)).Should().AllBeEquivalentTo(true);
}
public void consecutive_initiate_change_gets_finalized_and_switch_validators(ConsecutiveInitiateChangeTestParameters test)
{
var currentValidators = GenerateValidators(1);
SetupInitialValidators(currentValidators);
IAuRaValidatorProcessor validator = new ContractValidator(_validator, new MemDb(), _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _logManager, test.StartBlockNumber);
validator.SetFinalizationManager(_blockFinalizationManager);
test.TryDoReorganisations(test.StartBlockNumber, out _);
for (int i = 0; i < test.Current.NumberOfSteps; i++)
{
var blockNumber = test.Current.BlockNumber + i;
if (test.TryDoReorganisations(blockNumber, out var lastChain))
{
ValidateFinalizationForChain(lastChain);
i = 0;
blockNumber = test.Current.BlockNumber + i;
}
_block.Number = blockNumber;
_block.Beneficiary = currentValidators[i % currentValidators.Length];
_block.Hash = Keccak.Compute(blockNumber.ToString());
var txReceipts = test.GetReceipts(_block, _contractAddress, _abiEncoder, SetupAbiAddresses);
_block.Bloom = new Bloom(txReceipts.SelectMany(r => r.Logs).ToArray());
validator.PreProcess(_block);
validator.PostProcess(_block, txReceipts);
var finalizedNumber = blockNumber - validator.MinSealersForFinalization + 1;
_blockFinalizationManager.BlocksFinalized += Raise.EventWith(
new FinalizeEventArgs(_block.Header, Build.A.BlockHeader.WithNumber(finalizedNumber)
.WithHash(Keccak.Compute(finalizedNumber.ToString())).TestObject));
currentValidators = test.GetCurrentValidators(blockNumber);
var nextValidators = test.GetNextValidators(blockNumber);
currentValidators.Select(a => validator.IsValidSealer(a)).Should().AllBeEquivalentTo(true, $"Validator address is not recognized in block {blockNumber}");
nextValidators?.Except(currentValidators).Select(a => validator.IsValidSealer(a)).Should().AllBeEquivalentTo(false);
}
ValidateFinalizationForChain(test.Current);
}
public void from_OCCUPIED_DOOR_CLOSED_AWAITING_RFID_____wrong_RFID_detected()
{
//arrange
_doorSensor.DoorOpened += Raise.EventWith(EventArgs.Empty);
_chargeControl.PhoneConnected += Raise.EventWith(EventArgs.Empty);
_doorSensor.DoorClosed += Raise.EventWith(EventArgs.Empty);
_rfidReader.RfidDetected += Raise.EventWith(new RfidDetectedEventArgs(1234));
_verificationUnit.TryUnlockDoorWithReceivedID(4321).Returns(false);
//act
_rfidReader.RfidDetected += Raise.EventWith(new RfidDetectedEventArgs(4321));
//assert
_uut.VerificationUnit.Received(1).TryUnlockDoorWithReceivedID(4321);
_logger.Received(1).LogThis("Wrong RFID, door remains locked");
_userOutput.Received().Notify_WrongRfidUnlockingFailed();
}
public void from_VACANT_DOOR_OPEN_NO_PHONE_CONNECTED_to_VACANT_DOOR_CLOSED_NO_PHONE_CONNECTED()
{
//arrange
_doorSensor.DoorOpened += Raise.EventWith(EventArgs.Empty);
_chargeControl.PhoneConnected += Raise.EventWith(EventArgs.Empty);
_doorSensor.DoorClosed += Raise.EventWith(EventArgs.Empty);
_rfidReader.RfidDetected += Raise.EventWith(new RfidDetectedEventArgs(1234));
_verificationUnit.TryUnlockDoorWithReceivedID(1234).Returns(true);
_rfidReader.RfidDetected += Raise.EventWith(new RfidDetectedEventArgs(1234));
_doorSensor.DoorOpened += Raise.EventWith(EventArgs.Empty);
_chargeControl.PhoneDisconnected += Raise.EventWith(EventArgs.Empty);
//act
_doorSensor.DoorClosed += Raise.EventWith(EventArgs.Empty);
//assert
_logger.Received(2).LogThis("Door is closed");
_userOutput.Received().Notify_OpenDoorConnectPhone();
}
public async Task Valid_block_with_transactions_makes_it_is_processed_normally_if_beam_syncing_finished()
{
ISyncModeSelector syncModeSelector = Substitute.For <ISyncModeSelector>();
await SetupBeamProcessor(syncModeSelector);
syncModeSelector.Preparing += Raise.EventWith(new SyncModeChangedEventArgs(SyncMode.Beam, SyncMode.Full));
syncModeSelector.Changing += Raise.EventWith(new SyncModeChangedEventArgs(SyncMode.Beam, SyncMode.Full));
syncModeSelector.Changed += Raise.EventWith(new SyncModeChangedEventArgs(SyncMode.Beam, SyncMode.Full));
EthereumEcdsa ethereumEcdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
Block newBlock = Build.A.Block.WithParent(_blockTree.Head).WithReceiptsRoot(new Keccak("0xeb82c315eaf2c2a5dfc1766b075263d80e8b3ab9cb690d5304cdf114fff26939")).WithTransactions(Build.A.Transaction.SignedAndResolved(ethereumEcdsa, TestItem.PrivateKeyA).TestObject, Build.A.Transaction.SignedAndResolved(ethereumEcdsa, TestItem.PrivateKeyB).TestObject).WithGasUsed(42000).WithTotalDifficulty(_blockTree.Head.TotalDifficulty + 1).TestObject;
_blockTree.SuggestBlock(newBlock);
await Task.Delay(1000);
_blockchainProcessor.DidNotReceiveWithAnyArgs().Process(newBlock, ProcessingOptions.Beam, NullBlockTracer.Instance);
_blockchainProcessingQueue.Received().Enqueue(newBlock, ProcessingOptions.StoreReceipts);
}
public async Task ExecuteAsync_ShouldThrow_WhenDisposing()
{
// arrange
var control = testSut.SetupControl(ExifToolArguments.BoolFalse);
sut.Initialize();
var disposingTask = sut.DisposeAsync();
// act
control.Entered.WaitOne();
Func <Task> act = async() => _ = await sut.ExecuteAsync(null);
// assert
act.Should().Throw <Exception>().WithMessage("Disposing");
control.Release.Set();
shell.ProcessExited += Raise.WithEmpty();
await disposingTask;
}
void OutputTestData(IProcess process, string[] outputLines,
string[] errorLines = null)
{
foreach (var line in outputLines)
{
process.OutputDataReceived +=
Raise.Event <TextReceivedEventHandler>(this, new TextReceivedEventArgs(line));
}
process.OutputDataReceived +=
Raise.Event <TextReceivedEventHandler>(this, new TextReceivedEventArgs(null));
foreach (var line in errorLines ?? new string[] { })
{
process.ErrorDataReceived +=
Raise.Event <TextReceivedEventHandler>(this, new TextReceivedEventArgs(line));
}
process.ErrorDataReceived +=
Raise.Event <TextReceivedEventHandler>(this, new TextReceivedEventArgs(null));
}
public void UpdateTracks_ListOfTracksNotOnOldTracks_ListAdded()
{
//Arrange
var trackOne = new Track("one", _withinOne, DateTime.Now);
var trackTwo = new Track("two", _withinTwo, DateTime.Now);
var trackList = new List <ITrack>();
trackList.Add(trackOne);
trackList.Add(trackTwo);
var args = new EventTracks(trackList);
//Act
_filter.TracksFiltered += Raise.EventWith(args);
//Assert
Assert.That(_trackList.Count(), Is.EqualTo(2));
Assert.That(_trackList.Contains(trackOne));
Assert.That(_trackList.Contains(trackTwo));
}
public void OnFlightTrackDataReady_FlightTrackDataSourceToFlightTrackMultiple_FiveEventOneEntry(List <FTDataPoint> argsData, FlightTracksUpdatedEventArgs multipleData, List <IFlightTrack> tracker)
{
// Arrange
var testFlightTrackDataArgs = new FlightTrackDataEventArgs(argsData);
var testDataAfterEvent = new FlightTracksUpdatedEventArgs(new List <IFlightTrack>());
_uut.FlightTracksUpdated +=
(sender, args) => testDataAfterEvent.UpdatedFlights = args.UpdatedFlights;
// Act
for (int i = 0; i < 5; i++)
{
_testFlightTrackDataSource.FlightTrackDataReady += Raise.EventWith(this, testFlightTrackDataArgs);
}
// Assert
Assert.That(_outputEventCounter, Is.EqualTo(5));
Assert.That(testDataAfterEvent.UpdatedFlights.Count, Is.EqualTo(multipleData.UpdatedFlights.Count));
}
public void ItemEditorUpdateTriggersValidityCheck()
{
var sut = new ListDataEditor <ContainerStruct, ContainerStructValiditiState, EditableStruct, ValidationState>
(ItemValidatedEditorFactory,
ContainerStructMetadata.ItemsProperty,
GetItemValidityState);
var containerEditor = sut as IDataEditor <ContainerStruct>;
var implicitSut = sut as IValidatedComponent <ContainerStructValiditiState>;
var target = new ContainerStruct(new[]
{
new EditableStruct {
Text = "A"
},
});
// act
containerEditor.EditableTarget = target;
var itemEditor = sut.ItemEditors[0] as IValidatedComponent <ValidationState>;
itemEditor.Should().NotBeNull();
var structEditor = itemEditor as IDataEditor <EditableStruct>;
structEditor.Should().NotBeNull();
structEditor.EditableTarget = new EditableStruct {
Text = "B"
};
structEditor.TargetUpdated += Raise.EventWith(EventArgs.Empty);
// assert
target.Items[0].Text.Should().Be("B");
// act
implicitSut.UpdateValidationState(new ContainerStructValiditiState());
// assert
itemEditor.Received().UpdateValidationState(ValidationState.Valid);
}
public void ReferenceTypeEventHandlerWithInvalidArgumentType(
Exception exception)
{
const string ExpectedMessage =
"The event has the signature (FakeItEasy.Specs.ReferenceType), " +
"but the provided arguments have types (System.Collections.Hashtable).";
"Given an event of a custom delegate type taking only a reference type as an argument"
.See(() => nameof(Fake.ReferenceTypeEvent));
"When I raise the event specifying an argument of an invalid type"
.x(() => exception = Record.Exception(() =>
#pragma warning disable CS0618 // Type or member is obsolete
Fake.ReferenceTypeEvent += Raise.With <ReferenceTypeEventHandler>(new Hashtable())));
#pragma warning restore CS0618 // Type or member is obsolete
"Then the call fails with a meaningful message"
.x(() => exception.Should().BeAnExceptionOfType <FakeConfigurationException>().And
.Message.Should().Be(ExpectedMessage));
}
public void OnDoorOpened_StateCooking_CookerStopDisplayClear()
{
// Arrange
StringWriter output = new();
powerbutton.Pressed += Raise.EventWith(this, EventArgs.Empty);
timebutton.Pressed += Raise.EventWith(this, EventArgs.Empty);
startcancelbutton.Pressed += Raise.EventWith(this, EventArgs.Empty);
Console.SetOut(output);
//Act
door.Opened += Raise.EventWith(this, EventArgs.Empty);
//Assert
string expectedOutput = "Display cleared\r\n";
Assert.That(output.ToString(), Is.EqualTo(expectedOutput));
powertube.Received().TurnOff();
timer.Received().Stop();
}
void LoadFunc(MethodReference funcDef)
{
Raise <TypeCheckException> .If(_funcDecls.ContainsKey(funcDef.Name));
var funcRef = Module.Import(funcDef);
var funcDecl = new FunctionDecl();
funcDecl.Name = funcRef.Name;
funcDecl.ReturnType = GetType(funcRef.ReturnType.Name);
funcDecl.ReturnTypeName = funcDecl.ReturnType.Name;
funcDecl.Reference = funcRef;
foreach (var p in funcDef.Parameters)
{
var paramType = GetType(p.ParameterType.Name);
var paramInfo = funcDecl.AddParam(p.Name, paramType.Name);
paramInfo.Type = paramType;
paramInfo.Reference = p;
}
_funcDecls.Add(funcDef.Name, funcDecl);
}
public void AddTestFilesCommand_TellsModelToLoadTests()
{
var testFiles = new List <string>();
testFiles.Add("FILE1");
testFiles.Add("FILE2");
_model.TestFiles.Returns(testFiles);
var filesToAdd = new string[] { Path.GetFullPath("/path/to/test.dll") };
_view.DialogManager.SelectMultipleFiles(null, null).ReturnsForAnyArgs(filesToAdd);
var allFiles = new List <string>(testFiles);
allFiles.AddRange(filesToAdd);
_view.AddTestFilesCommand.Execute += Raise.Event <CommandHandler>();
_model.Received().LoadTests(Arg.Compat.Is <List <string> >(l => l.SequenceEqual(allFiles)));
}
public void HandleFlightsInAirspace_NoConflictingFlights_NoEventRaises()
{
int raises = 0;
_uut.SeperationEvent += (sender, args) => raises++;
List <Track> tracks = new List <Track>();
for (int i = 0; i < 10; i++)
{
tracks.Add(new Track());
}
_fakeCollisionAnalyzer.AnalyzeCollision(Arg.Any <Track>(), Arg.Any <Track>()).Returns(false);
FlightMovementEventArgs arg = new FlightMovementEventArgs(tracks, tracks);
_fakeFlightManagement.FlightDataReady += Raise.EventWith <FlightMovementEventArgs>(arg);
_fakeSeparationStringBuilder.DidNotReceive().BuildSeperationNote(Arg.Any <Track>(), Arg.Any <Track>());
}
public async Task ClosingTextViewDisposesFile()
{
var textView = CreateTextView();
var target = new PullRequestSessionManager(
CreatePullRequestService(),
CreateSessionService(),
CreateRepositoryHosts(),
new FakeTeamExplorerServiceHolder(CreateRepositoryModel()));
var file = (PullRequestSessionLiveFile)await target.GetLiveFile(FilePath, textView, textView.TextBuffer);
var compositeDisposable = file.ToDispose as CompositeDisposable;
Assert.NotNull(compositeDisposable);
Assert.False(compositeDisposable.IsDisposed);
textView.Closed += Raise.Event();
Assert.True(compositeDisposable.IsDisposed);
}
public void ShouldNotifyWhenFileWasCreatedAndNameIncludedInFilter()
{
//Given
var createdEvents = new Stack <FileChangedEventArgs>();
var fileWatchDog = _kernel.Get <IFileSystemWatchDog>();
//When
var disp = fileWatchDog.Watch(ObserverDirPath)
.Filter(Filters.Name("index"))
.Subscribe(e => createdEvents.Push(e));
_monitorService.Created += Raise.EventWith(new FileCreatedEventArgs(FileCreatedEventMessage, FileName));
_monitorService.Created += Raise.EventWith(new FileCreatedEventArgs(FileCreatedEventMessage, "index.txt"));
disp.Dispose();
//Then
_monitorService.Received(1).Dispose();
Assert.Equal("index.txt", createdEvents.Pop().Name);
Assert.Equal(FileName, createdEvents.Pop().Name);
}
public void TransmitTest()
{
//Arrange
var objWebSocketClient = Substitute.For <IWebSocketClient>();
var objKeepAliveMonitor = Substitute.For <IKeepAliveMonitor>();
var objClient = new WebsocketClient(objWebSocketClient, objKeepAliveMonitor);
objClient.ConnectAsync(new ClientParams()
{
HostName = "localhost", Port = 80, Secure = false
});
objWebSocketClient.Received().OnOpen += Raise.EventWith(objWebSocketClient, new EventArgs());
//Act
objClient.Transmit(new byte[] { 1, 2, 3, 4 });
Thread.Sleep(50); //-- wait a bit so the sender queue can call the IWebSocketClient.Send() method
//Assert
objWebSocketClient.Received(1).SendAsync(Arg.Is <byte[]>(b => b.SequenceEqual(new byte[] { 1, 2, 3, 4 })));
}
public void TestRfidDetected_Locked_checkOldId()
{
//Arrange
_chargeControl.isConnected().Returns(true);
//Act
_rfid.RfidEvent +=
Raise.EventWith(new RfidEventArgs()
{
Rfid_ID = 1234
});
_rfid.RfidEvent +=
Raise.EventWith(new RfidEventArgs()
{
Rfid_ID = 1234
});
//Assert
Assert.That(_uut.OldId, Is.EqualTo(1234));
}
public void TestDoorStateChangedDetected_DoorOpen_DoorClosedTrue_Display()
{
//Arrange
// _chargeControl.isConnected().Returns(false);
//Act
_door.DoorEvent +=
Raise.EventWith(new DoorEventArgs()
{
DoorClosed = false
});
_door.DoorEvent +=
Raise.EventWith(new DoorEventArgs()
{
DoorClosed = true
});
//Assert
_display.Received().displayCommands("Read rfid (press 'R')");
}
public void TestRfidDetected_Locked_testStopCharging()
{
//Arrange
_chargeControl.isConnected().Returns(true);
//Act
_rfid.RfidEvent +=
Raise.EventWith(new RfidEventArgs()
{
Rfid_ID = 1234
});
_rfid.RfidEvent +=
Raise.EventWith(new RfidEventArgs()
{
Rfid_ID = 1234
});
//Assert
_chargeControl.Received().StopCharge();
}
public void TestDoorStateChangedDetected_DoorLockedTrue_Display()
{
//Arrange
_chargeControl.isConnected().Returns(true);
_rfid.RfidEvent +=
Raise.EventWith(new RfidEventArgs()
{
Rfid_ID = 1234
});
//Act
_door.DoorEvent +=
Raise.EventWith(new DoorEventArgs()
{
DoorClosed = true
});
//Assert
_display.Received().displayCommands("Locker is occupied");
}
public void testOutplutOfListInterpreter(string s)
{
List <string> strings = new List <string>();
foreach (string data in s.Split(','))
{
strings.Add(data);
}
RawTransponderDataEventArgs args = new RawTransponderDataEventArgs(strings);
handler.TransponderDataReady += Raise.EventWith(this, args);
List <string> stringsOut = new List <string>();
foreach (var trackOut in TrackListArgs.Tracks)
{
stringsOut.Add(trackOut.Tag + ";" + trackOut.TrackPosition.XCoordinate + ";" + trackOut.TrackPosition.YCoordinate + ";" + trackOut.TrackPosition.ZCoordinate + ";" + trackOut.TimeStamp);
}
Assert.That(stringsOut.SequenceEqual(strings));
}
public void ShouldAddAndRemoveHandlersFromFakeEvent()
{
//given
var globalHotkey = A.Fake <GlobalHotkey>();
var counter = 0;
EventHandler firstHandler = (sender, args) => counter++;
EventHandler secondHandler = (sender, args) => counter++;
globalHotkey.HotkeyPressed += firstHandler;
globalHotkey.HotkeyPressed += secondHandler;
globalHotkey.HotkeyPressed -= firstHandler;
//when
globalHotkey.HotkeyPressed += Raise.WithEmpty();
//then
Assert.That(counter, Is.EqualTo(1));
}
public void DataReceivedTest()
{
//Arrange
var objMessageProcessor = Substitute.For <IMessageProcessor>();
var objConnection = Substitute.For <IClientConnection>();
var objRoutingFrame = new RoutingFrame(RoutingFrameType.Messaging, MessageType.Request, "MyRequestID", "MySourceID", "MyDestinationID", new byte[] { 1, 2, 3, 4 });
Config.Initialize(new Config.ConfigParams()
{
MessageProcessor = objMessageProcessor
});
//Act
var obj = new PassThroughRouter(objConnection);
objConnection.Rx += Raise.Event <EventHandler <byte[]> >(objConnection, objRoutingFrame.GetBytes());
//Assert
objMessageProcessor.Received(1).Process(Arg.Is(obj), Arg.Is <byte[]>(b => b.SequenceEqual(new byte[] { 1, 2, 3, 4 })));
}
internal static stmt Convert(Statement stmt) {
stmt ast;
if (stmt is FunctionDefinition)
ast = new FunctionDef((FunctionDefinition)stmt);
else if (stmt is ReturnStatement)
ast = new Return((ReturnStatement)stmt);
else if (stmt is AssignmentStatement)
ast = new Assign((AssignmentStatement)stmt);
else if (stmt is AugmentedAssignStatement)
ast = new AugAssign((AugmentedAssignStatement)stmt);
else if (stmt is DelStatement)
ast = new Delete((DelStatement)stmt);
else if (stmt is PrintStatement)
ast = new Print((PrintStatement)stmt);
else if (stmt is ExpressionStatement)
ast = new Expr((ExpressionStatement)stmt);
else if (stmt is ForStatement)
ast = new For((ForStatement)stmt);
else if (stmt is WhileStatement)
ast = new While((WhileStatement)stmt);
else if (stmt is IfStatement)
ast = new If((IfStatement)stmt);
else if (stmt is WithStatement)
ast = new With((WithStatement)stmt);
else if (stmt is RaiseStatement)
ast = new Raise((RaiseStatement)stmt);
else if (stmt is TryStatement)
ast = Convert((TryStatement)stmt);
else if (stmt is AssertStatement)
ast = new Assert((AssertStatement)stmt);
else if (stmt is ImportStatement)
ast = new Import((ImportStatement)stmt);
else if (stmt is FromImportStatement)
ast = new ImportFrom((FromImportStatement)stmt);
else if (stmt is ExecStatement)
ast = new Exec((ExecStatement)stmt);
else if (stmt is GlobalStatement)
ast = new Global((GlobalStatement)stmt);
else if (stmt is ClassDefinition)
ast = new ClassDef((ClassDefinition)stmt);
else if (stmt is BreakStatement)
ast = new Break();
else if (stmt is ContinueStatement)
ast = new Continue();
else if (stmt is EmptyStatement)
ast = new Pass();
else
throw new ArgumentTypeException("Unexpected statement type: " + stmt.GetType());
ast.GetSourceLocation(stmt);
return ast;
}
