AssertOutArgument.AreEqual(output, "sum", 3);
}

[RequiredArgument]
public InArgument<string> BookmarkName { get; set; }

protectedoverridebool CanInduceIdle
{
get { returntrue; }
}

public BookmarkCallback ReadCompleteCallback
{
get { return _readCompleteCallback ?? (_readCompleteCallback =new BookmarkCallback(OnReadComplete)); }
}

protectedoverridevoid Execute(NativeActivityContext context)
{
// Inform the host that this activity needs data and wait for the callback
context.CreateBookmark(BookmarkName.Get(context), ReadCompleteCallback);
}

privatevoid OnReadComplete(NativeActivityContext context, Bookmark bookmark, object state)
{
// Store the value returned by the host
context.SetValue(Result, state asstring);
}
}

// Act

// Run the workflow
sut.TestActivity();

// Wait for the first idle event - prompt for First Name
// will return false if the activity does not go idle within the
// timeout (default 1 sec)
Assert.IsTrue(sut.WaitForIdleEvent());

// Should have a bookmark named "FirstName"
Assert.IsTrue(sut.Bookmarks.Contains("FirstName"));

Assert.AreEqual(BookmarkResumptionResult.Success,
sut.TestWorkflowApplication.ResumeBookmark("FirstName", expectedFirstName));

// Wait for the second idle event - prompt for Last Name
Assert.IsTrue(sut.WaitForIdleEvent());

// Should have a bookmark named "LastName"
Assert.IsTrue(sut.Bookmarks.Contains("LastName"));

Assert.AreEqual(BookmarkResumptionResult.Success,
sut.TestWorkflowApplication.ResumeBookmark("LastName", expectedLastName));

// Wait for the workflow to complete
Assert.IsTrue(sut.WaitForCompletedEvent());

// Assert
// WorkflowApplicationTest.TextLines returns an array of strings
// that contains strings written by the WriteLine activity
Assert.AreEqual(4, sut.TextLines.Length);
Assert.AreEqual(expectedGreeting, sut.TextLines[2]);
}

protectedoverridevoid CacheMetadata(CodeActivityMetadata metadata)
{
// This activity requires the average extension
metadata.RequireExtension(typeof (AverageExtension));

// This lambda will create one if it is not already added
metadata.AddDefaultExtensionProvider(() =>new AverageExtension());

base.CacheMetadata(metadata);
}

protectedoverridestring Execute(CodeActivityContext context)
{
// Get the average extension
var average = context.GetExtension<AverageExtension>();

if (average ==null)
thrownew InvalidOperationException("Cannot access AverageExtension");

var number = Number.Get(context);

// Store this number
average.StoreNumber(number);

returnstring.Format("Stored {0}, Average:{1}", number, average.GetAverage());
}
}

///<summary>
/// The endpoint address to be used by the test host
///</summary>
privatereadonly EndpointAddress _serviceAddress =new EndpointAddress("net.pipe://localhost/TestService");

///<summary>
/// Tests the GetAverage Activity by invoking it in a WorkflowService multiple times
///</summary>
[TestMethod()]
[DeploymentItem("Service1.xamlx")]
publicvoid ShouldInvokeAverageExtension()
{
conststring expected1 ="Stored 33, Average:33";
conststring expected2 ="Stored 44, Average:38.5";
conststring expected3 ="Stored 55, Average:44";

string result1;
string result2;
string result3;

// Self-Host Service1.xamlx using Named Pipes
using (var testHost = WorkflowServiceTestHost.Open("Service1.xamlx", _serviceAddress.Uri))
{
// Use the generated proxy with named pipes
var proxy =new ServiceClient(_binding, _serviceAddress);

try
{
result1 = proxy.GetData(33);
result2 = proxy.GetData(44);
result3 = proxy.GetData(55);
proxy.Close();
}
catch (Exception)
{
proxy.Abort();
throw;
}

Assert.AreEqual(expected1, result1);
Assert.AreEqual(expected2, result2);
Assert.AreEqual(expected3, result3);
}
}