public void TestConstructorWithAlreadyEndedTransaction()
{
WeightedTransaction <Transaction> testTransaction = new WeightedTransaction <Transaction>(
Transaction.EndedDummy
);
IObservationSubscriber subscriber = this.mockery.NewMock <IObservationSubscriber>();
Expect.AtLeast(0).On(subscriber).Method("ProgressUpdated");
// This should no be called because otherwise, the 'Ended' event would be raised
// to the transaction group before all transactions have been added into
// the internal list, leading to an early ending or even multiple endings.
Expect.Never.On(subscriber).Method("Ended");
using (
ObservedWeightedTransaction <Transaction> test =
new ObservedWeightedTransaction <Transaction>(
testTransaction,
new ObservedWeightedTransaction <Transaction> .ReportDelegate(
subscriber.ProgressUpdated
),
new ObservedWeightedTransaction <Transaction> .ReportDelegate(
subscriber.Ended
)
)
) {
this.mockery.VerifyAllExpectationsHaveBeenMet();
}
}
public void TestConstructorWithEndingTransaction()
{
WeightedTransaction <Transaction> testTransaction = new WeightedTransaction <Transaction>(
new FunkyTransaction()
);
IObservationSubscriber subscriber = this.mockery.NewMock <IObservationSubscriber>();
Expect.AtLeast(0).On(subscriber).Method("ProgressUpdated");
Expect.Once.On(subscriber).Method("Ended");
using (
ObservedWeightedTransaction <Transaction> test =
new ObservedWeightedTransaction <Transaction>(
testTransaction,
new ObservedWeightedTransaction <Transaction> .ReportDelegate(
subscriber.ProgressUpdated
),
new ObservedWeightedTransaction <Transaction> .ReportDelegate(
subscriber.Ended
)
)
) {
this.mockery.VerifyAllExpectationsHaveBeenMet();
}
}
public void TestConstructorWithEndingTransaction()
{
WeightedTransaction <Transaction> testTransaction = new WeightedTransaction <Transaction>(
new FunkyTransaction()
);
Mock <IObservationSubscriber> subscriber = this.mockery.CreateMock <IObservationSubscriber>();
subscriber.Expects.AtLeast(0).Method(m => m.ProgressUpdated());
subscriber.Expects.One.Method(m => m.Ended());
using (
ObservedWeightedTransaction <Transaction> test =
new ObservedWeightedTransaction <Transaction>(
testTransaction,
new ObservedWeightedTransaction <Transaction> .ReportDelegate(
subscriber.MockObject.ProgressUpdated
),
new ObservedWeightedTransaction <Transaction> .ReportDelegate(
subscriber.MockObject.Ended
)
)
) {
this.mockery.VerifyAllExpectationsHaveBeenMet();
}
}
public void TestWeightStorage()
{
TestTransaction transaction = new TestTransaction();
WeightedTransaction <Transaction> testWrapper = new WeightedTransaction <Transaction>(
transaction, 12.0f
);
Assert.AreEqual(12.0f, testWrapper.Weight);
}
public void TestDefaultWeight()
{
TestTransaction transaction = new TestTransaction();
WeightedTransaction <Transaction> testWrapper = new WeightedTransaction <Transaction>(
transaction
);
Assert.AreEqual(1.0f, testWrapper.Weight);
}
public void TestTransactionStorage()
{
TestTransaction transaction = new TestTransaction();
WeightedTransaction <Transaction> testWrapper = new WeightedTransaction <Transaction>(
transaction
);
Assert.AreSame(transaction, testWrapper.Transaction);
}
/// <summary>Initializes a new observed transaction</summary>
/// <param name="weightedTransaction">Weighted transaction being observed</param>
/// <param name="progressUpdateCallback">
/// Callback to invoke when the transaction's progress changes
/// </param>
/// <param name="endedCallback">
/// Callback to invoke when the transaction has ended
/// </param>
internal ObservedWeightedTransaction(
WeightedTransaction <TransactionType> weightedTransaction,
ReportDelegate progressUpdateCallback,
ReportDelegate endedCallback
)
{
this.weightedTransaction = weightedTransaction;
// See if this transaction has already ended (initial check for performance)
if (weightedTransaction.Transaction.Ended)
{
// Since we don't subscribe to the .Ended event (which would be fired immediately on
// subscription if the transaction was already finished), we will emulate this
// behavior here. There is no race condition here: The transition to .Ended occurs
// only once and will never happen in reverse. This is just a minor optimization to
// prevent object coupling where none is neccessary and to save some processing time.
this.progress = 1.0f;
progressUpdateCallback();
// Do not call the ended callback here. This constructor is called when the
// TransactionGroup constructs its list of transactions. If this is called and
// the first transaction to be added to the group happens to be in the ended
// state, the transactionGroup will immediately think it has ended!
//!DONT!endedCallback();
return;
}
this.endedCallback = endedCallback;
this.progressUpdateCallback = progressUpdateCallback;
// This might trigger the event handler to be invoked right here if the transaction
// ended between our initial optimization attempt and this line. It's unlikely,
// however, so we'll not waste time with another optimization attempt.
this.weightedTransaction.Transaction.AsyncEnded += new EventHandler(asyncEnded);
// See whether this transaction implements the IProgressReporter interface and if
// so, connect to its progress report event in order to pass these reports on
// to whomever created ourselfes.
this.progressReporter = this.weightedTransaction.Transaction as IProgressReporter;
if (this.progressReporter != null)
{
this.asyncProgressChangedEventHandler = new EventHandler <ProgressReportEventArgs>(
asyncProgressChanged
);
this.progressReporter.AsyncProgressChanged += this.asyncProgressChangedEventHandler;
}
}
public void TestWrapperCollection()
{
WeightedTransaction <Transaction> transaction = new WeightedTransaction <Transaction>(
Transaction.EndedDummy
);
ObservedWeightedTransaction <Transaction> observed =
new ObservedWeightedTransaction <Transaction>(
transaction,
endedCallback,
progressUpdatedCallback
);
WeightedTransactionWrapperCollection <Transaction> wrapper =
new WeightedTransactionWrapperCollection <Transaction>(
new ObservedWeightedTransaction <Transaction>[] { observed }
);
Assert.AreSame(transaction, wrapper[0]);
}
