public void HttpOperationDescription_Insert_OutputParameters_From_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescriptionCollection mpdColl = od.Messages[1].Body.Parts;
Assert.AreEqual(1, mpdColl.Count, "Test assumes we start with 1 output param");
// Get a synchronized HOD and HODCollection
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
// Get an HPD for the newly created MPD
MessagePartDescription mpdNew = new MessagePartDescription("NewMPD", "NewMPDNS")
{
Type = typeof(byte)
};
HttpParameterDescription hpd = mpdNew.ToHttpParameterDescription();
// Add it to the output parameters
hpdColl.Add(hpd);
// Verify it appears in the MPD coll
Assert.AreEqual(2, mpdColl.Count, "Adding new MPD to HPD collection should have updated MPD collection");
Assert.AreEqual(2, od.Messages[1].Body.Parts.Count, "Adding new MPD should have updated Parts");
Assert.AreEqual(typeof(byte), od.Messages[1].Body.Parts[1].Type, "Adding new MPD failed due to type");
}
public void HttpParameterDescriptionCollection_Ctor_From_Output_MessagePartDescriptionCollection()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection(od, isOutputCollection: true);
Assert.IsNotNull(coll, "Failed to create HttpParameterDescriptionCollection");
Assert.AreEqual(1, coll.Count, "HttpParameterDescriptionCollection should have found 1 parameter");
HttpParameterDescription hpd = coll[0];
Assert.AreEqual("outParameter", hpd.Name, "Name was not set correctly");
Assert.AreEqual(typeof(double), hpd.ParameterType, "ParameterType was not set correctly");
Assert.AreEqual(0, hpd.Index, "Index was not set correctly");
}
public void HttpOperationDescription_Can_Be_Created_From_Simple_Types()
{
HttpOperationDescription hod = new HttpOperationDescription();
hod.ReturnValue = new HttpParameterDescription()
{
Name = "Return",
Namespace = "ReturnNS",
ParameterType = typeof(string),
Index = 0
};
hod.InputParameters.Add(new HttpParameterDescription()
{
Name = "InParameter",
Namespace = "InParameterNS",
ParameterType = typeof(int),
Index = 0
});
hod.OutputParameters.Add(new HttpParameterDescription()
{
Name = "OutParameter",
Namespace = "OutParameterNS",
ParameterType = typeof(string),
Index = 1
});
HttpParameterDescription parmDesc = hod.ReturnValue;
Assert.AreEqual("Return", parmDesc.Name, "ReturnValue.Name incorrect");
Assert.AreEqual("ReturnNS", parmDesc.Namespace, "ReturnValue.Namespace incorrect");
Assert.AreEqual(typeof(string), parmDesc.ParameterType, "ReturnValue.ParameterType incorrect");
Assert.AreEqual(0, parmDesc.Index, "ReturnValue.Index incorrect");
HttpParameterDescriptionCollection coll = hod.InputParameters;
Assert.AreEqual(1, coll.Count, "Input parameter collection should have 1 element");
parmDesc = coll[0];
Assert.AreEqual("InParameter", parmDesc.Name, "InputParameter.Name incorrect");
Assert.AreEqual("InParameterNS", parmDesc.Namespace, "InputParameter.Namespace incorrect");
Assert.AreEqual(typeof(int), parmDesc.ParameterType, "InputParameter.ParameterType incorrect");
Assert.AreEqual(0, parmDesc.Index, "InputParameter.Index incorrect");
coll = hod.OutputParameters;
Assert.AreEqual(1, coll.Count, "Output parameter collection should have 1 element");
parmDesc = coll[0];
Assert.AreEqual("OutParameter", parmDesc.Name, "OutParameter.Name incorrect");
Assert.AreEqual("OutParameterNS", parmDesc.Namespace, "OutParameter.Namespace incorrect");
Assert.AreEqual(typeof(string), parmDesc.ParameterType, "OutParameter.ParameterType incorrect");
Assert.AreEqual(1, parmDesc.Index, "OutParameter.Index incorrect");
}
public void HttpOperationDescription_Update_OutputParameters_From_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescription mpd = od.Messages[1].Body.Parts[0]; // output parameter 1 in the MPD
Assert.AreEqual(typeof(double), mpd.Type, "MPD out parameter 1 has wrong type");
// Get a synchronized HOD.
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
// Get a synchronized HPDCollection and from it a synchronized HPD
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
HttpParameterDescription hpd = hpdColl[0];
Assert.IsNotNull(hpd, "Input parameter was null");
Assert.AreEqual(typeof(double), hpd.ParameterType, "HPD out parameter 1 has wrong type");
// Negative test -- Name and Namespace are immutable when synchronized
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting Name should throw when synchronized",
() => hpd.Name = "Rename"
);
ExceptionAssert.Throws(
typeof(NotSupportedException),
"Setting Name should throw when synchronized",
() => hpd.Name = "Rename"
);
// Update return value directly in HOD's parameter description
hpd.ParameterType = typeof(int);
hpd.Index = 5;
// This should have directly updated it in the MPD as well
Assert.AreEqual(typeof(int), mpd.Type, "HPD failed to update ParameterType in MPD");
Assert.AreEqual(5, mpd.Index, "HPD failed to update Index in MPD");
// Final test -- and that should have updated it in the OD.
// This is technically the same test as above, but this proves it.
Assert.AreEqual(typeof(int), od.Messages[1].Body.Parts[0].Type, "HPD failed to update ParameterType in MPD");
Assert.AreEqual(5, od.Messages[1].Body.Parts[0].Index, "HPD failed to update Index in MPD");
}
public void HttpParameterDescriptionCollection_Ctor_From_Mock_HttpParameterDescriptions()
{
HttpParameterDescription[] paramDescs = new[] {
new HttpParameterDescription() { Name="First", Namespace="FirstNS", ParameterType=typeof(string), Index=0 },
new HttpParameterDescription() { Name="Second", Namespace="SecondNS", ParameterType=typeof(int), Index=1 },
};
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection(paramDescs.ToList());
Assert.AreEqual(2, coll.Count, "HttpParameterDescriptionCollection should have found 2 parameters");
Assert.AreEqual("First", coll[0].Name, "Name1 was not set correctly");
Assert.AreEqual("FirstNS", coll[0].Namespace, "Namespace1 was not set correctly");
Assert.AreEqual(typeof(string), coll[0].ParameterType, "Type1 was not set correctly");
Assert.AreEqual(0, coll[0].Index, "Index1 was not set correctly");
Assert.AreEqual("Second", coll[1].Name, "Name2 was not set correctly");
Assert.AreEqual("SecondNS", coll[1].Namespace, "Namespace2 was not set correctly");
Assert.AreEqual(typeof(int), coll[1].ParameterType, "Type2 was not set correctly");
Assert.AreEqual(1, coll[1].Index, "Index2 was not set correctly");
}
public void HttpOperationDescription_Delete_OutputParameters_From_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescription mpd = od.Messages[1].Body.Parts[0]; // input parameter 1 in the MPD
// Get a synchronized HOD.
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
// Get a synchronized HPDCollection and from it a synchronized HPD
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
Assert.AreEqual(1, hpdColl.Count, "Expected HPD collection to have one output param");
// Delete it from our collection
hpdColl.RemoveAt(0);
// Verify the backing OD has seen that change
Assert.AreEqual(0, od.Messages[1].Body.Parts.Count, "Expected delete of HPD input parameter to delete it from OD");
}
public void HttpOperationDescription_Update_OutputParameters_From_Incomplete_HttpOperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
MessagePartDescription mpd = od.Messages[1].Body.Parts[0]; // output parameter 1 in the MPD
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = hod.OutputParameters;
HttpParameterDescription hpd = hpdColl[0];
// Zap the Messages[]
od.Messages.Clear();
// Zapping the backing Messages should have rendered the input collection empty
Assert.AreEqual(0, hpdColl.Count, "Resetting Messages did not reset count");
Assert.AreEqual(0, hod.InputParameters.Count, "Resetting Messages did not reset count in HOD");
// Mutating the OutputParameter collection should auto-create the both in and out Messages
hpdColl.Add(hpd);
Assert.AreEqual(2, od.Messages.Count, "Messages[1] was not autocreated");
Assert.AreEqual(1, hpdColl.Count, "Creating Messages did not set count");
Assert.AreEqual(1, hod.OutputParameters.Count, "Creating Messages did not set count in HOD");
}
public void HttpOperationDescription_Default_Ctor()
{
HttpOperationDescription hod = new HttpOperationDescription();
HttpParameterDescription returnValue = hod.ReturnValue;
Assert.IsNull(returnValue, "ReturnValue should initialize to null");
Collection <Attribute> attributes = hod.Attributes;
Assert.IsNotNull(attributes, "Attributes should initialize to non-null");
Assert.AreEqual(0, attributes.Count, "Attributes should initialize to empty collection");
HttpParameterDescriptionCollection inputs = hod.InputParameters;
Assert.IsNotNull(inputs, "InputParameters should initialize to non-null");
Assert.AreEqual(0, inputs.Count, "InputParameters should initialize to empty collection");
HttpParameterDescriptionCollection outputs = hod.OutputParameters;
Assert.IsNotNull(outputs, "OutputParameters should initialize to non-null");
Assert.AreEqual(0, outputs.Count, "OutputParameters should initialize to empty collection");
KeyedByTypeCollection <IOperationBehavior> behaviors = hod.Behaviors;
Assert.IsNotNull(behaviors, "Behaviors should initialize to non-null");
Assert.AreEqual(0, behaviors.Count, "Behaviors should initialize to empty");
Collection <Type> knownTypes = hod.KnownTypes;
Assert.IsNotNull(knownTypes, "knownTypes should initialize to non-null");
Assert.AreEqual(0, knownTypes.Count, "knownTypes should initialize to empty");
Assert.IsNull(hod.BeginMethod, "BeginMethod should initialize to null");
Assert.IsNull(hod.EndMethod, "EndMethod should initialize to null");
Assert.IsNull(hod.SyncMethod, "SyncMethod should initialize to null");
Assert.IsNull(hod.DeclaringContract, "DeclaringContract should initialize to null");
}
public void HttpOperationDescription_Update_InputParameters_From_OperationDescription()
{
OperationDescription od = GetOperationDescription(typeof(MockService2), "GetAStringFromInt");
OperationDescription od2 = GetOperationDescription(typeof(MockService2), "OneInOneOutReturnsString");
HttpOperationDescription hod = od.ToHttpOperationDescription();
Assert.IsNotNull(hod, "Failed to create HttpOperationDescription");
// Just confirm initial creation was correct
HttpParameterDescriptionCollection inputParameters = hod.InputParameters;
Assert.AreEqual(1, inputParameters.Count, "Expected one input parameter");
Assert.AreEqual(typeof(int), inputParameters[0].ParameterType, "Expected int type");
// Replace the messages from 2nd OD
od.Messages[0] = od2.Messages[0];
inputParameters = hod.InputParameters;
Assert.IsNotNull(inputParameters, "InputParameters should not be null after update");
Assert.AreEqual(1, inputParameters.Count, "Expected one input parameter after update");
Assert.AreEqual(typeof(char), inputParameters[0].ParameterType, "Expected char type after update");
}
public void HttpParameterDescriptionCollection_Synchronized_Implements_Clear()
{
OperationDescription od1 = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
MessagePartDescriptionCollection mpdColl = od1.Messages[0].Body.Parts;
Assert.AreEqual(2, mpdColl.Count, "MessagePartDescriptionCollection should show 2 existing input parameters");
// This ctor creates the synchronized form of the collection. It should immediately reflect
// the state of the MPD collection
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od1, isOutputCollection: false);
hpdColl.Clear();
Assert.AreEqual(0, hpdColl.Count, "Clear failed");
}
public void HttpParameterDescriptionCollection_Synchronized_GetEnumerator()
{
OperationDescription od1 = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
OperationDescription od2 = GetOperationDescription(typeof(MockService3), "SampleMethod");
MessagePartDescriptionCollection mpdColl = od1.Messages[0].Body.Parts;
Assert.AreEqual(2, mpdColl.Count, "MessagePartDescriptionCollection should show 2 existing input parameters");
MessagePartDescriptionCollection mpdColl2 = od2.Messages[0].Body.Parts;
Assert.AreEqual(1, mpdColl2.Count, "MessagePartDescriptionCollection 2 should show 1 existing input parameters");
// Pull out individual parts to test synching at item level
MessagePartDescription mpd1 = mpdColl[0];
MessagePartDescription mpd2 = mpdColl[1];
// Use a MPD from a 2nd collection so we can add and remove it
MessagePartDescription mpd3 = mpdColl2[0];
// This ctor creates the synchronized form of the collection. It should immediately reflect
// the state of the MPD collection
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od1, isOutputCollection: false);
Assert.IsNotNull(hpdColl, "Failed to create HttpParameterDescriptionCollection");
Assert.AreEqual(2, hpdColl.Count, "HttpParameterDescriptionCollection should show 2 existing input parameters");
// Extension method creates synched version of HPD from MPD's
HttpParameterDescription hpd1 = mpd1.ToHttpParameterDescription();
HttpParameterDescription hpd2 = mpd2.ToHttpParameterDescription();
// Ensure the extension method created HPD's that point to the idential MPD
Assert.AreEqual(mpd1, hpd1.MessagePartDescription, "HttParameterDescription 1 linked to wrong MessagePartDescription");
Assert.AreEqual(mpd2, hpd2.MessagePartDescription, "HttParameterDescription 2 linked to wrong MessagePartDescription");
// Keep one from 2nd collection
HttpParameterDescription hpd3 = mpd3.ToHttpParameterDescription();
// GetEnumerator
IEnumerator<HttpParameterDescription> ie = hpdColl.GetEnumerator();
object[] items = EnumeratorToArray(ie);
AssertSame(hpdColl, items, "Generic enumerator");
// Non-generic GetEnumerator
IEnumerator iec = ((IEnumerable)hpdColl).GetEnumerator();
Assert.IsNotNull(iec, "GetEnumerator failed");
items = EnumeratorToArray(iec);
AssertSame(hpdColl, items, "Nongeneric enumerator");
}
private static void AssertSame(HttpParameterDescriptionCollection coll, object[] items, string message)
{
Assert.AreEqual(coll.Count, items.Length, message + ": length mismatch");
for (int i = 0; i < items.Length; ++i)
{
HttpParameterDescription hpd1 = coll[i];
HttpParameterDescription hpd2 = items[i] as HttpParameterDescription;
Assert.IsNotNull(hpd1, message + ": null in collection");
Assert.IsNotNull(hpd2, message + ": null in items");
Assert.AreSame(hpd1.MessagePartDescription, hpd2.MessagePartDescription, message + ": different MessagePartDescriptions");
}
}
public void HttpParameterDescriptionCollection_Synchronized_CopyTo()
{
OperationDescription od1 = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
OperationDescription od2 = GetOperationDescription(typeof(MockService3), "SampleMethod");
MessagePartDescriptionCollection mpdColl = od1.Messages[0].Body.Parts;
Assert.AreEqual(2, mpdColl.Count, "MessagePartDescriptionCollection should show 2 existing input parameters");
MessagePartDescriptionCollection mpdColl2 = od2.Messages[0].Body.Parts;
Assert.AreEqual(1, mpdColl2.Count, "MessagePartDescriptionCollection 2 should show 1 existing input parameters");
// Pull out individual parts to test synching at item level
MessagePartDescription mpd1 = mpdColl[0];
MessagePartDescription mpd2 = mpdColl[1];
// Use a MPD from a 2nd collection so we can add and remove it
MessagePartDescription mpd3 = mpdColl2[0];
// This ctor creates the synchronized form of the collection. It should immediately reflect
// the state of the MPD collection
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od1, isOutputCollection: false);
Assert.IsNotNull(hpdColl, "Failed to create HttpParameterDescriptionCollection");
Assert.AreEqual(2, hpdColl.Count, "HttpParameterDescriptionCollection should show 2 existing input parameters");
// Extension method creates synched version of HPD from MPD's
HttpParameterDescription hpd1 = mpd1.ToHttpParameterDescription();
HttpParameterDescription hpd2 = mpd2.ToHttpParameterDescription();
// Ensure the extension method created HPD's that point to the idential MPD
Assert.AreEqual(mpd1, hpd1.MessagePartDescription, "HttParameterDescription 1 linked to wrong MessagePartDescription");
Assert.AreEqual(mpd2, hpd2.MessagePartDescription, "HttParameterDescription 2 linked to wrong MessagePartDescription");
// Keep one from 2nd collection
HttpParameterDescription hpd3 = mpd3.ToHttpParameterDescription();
// CopyTo
HttpParameterDescription[] arr = new HttpParameterDescription[2];
hpdColl.CopyTo(arr, 0);
Assert.AreSame(hpd1.MessagePartDescription, arr[0].MessagePartDescription, "CopyTo[0] failed");
Assert.AreSame(hpd2.MessagePartDescription, arr[1].MessagePartDescription, "CopyTo[1] failed");
// CopyTo negative tests
ExceptionAssert.ThrowsArgumentNull(
"CopyTo throws argument null for null array",
"array",
() => hpdColl.CopyTo(null, 0)
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"CopyTo should throw for negative index",
() => hpdColl.CopyTo(arr, -1),
"arrayIndex"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"CopyTo should throw for too large an index",
() => hpdColl.CopyTo(arr, 2),
"arrayIndex"
);
}
public void HttpParameterDescriptionCollection_Unsynchronized_CopyTo()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
coll.Add(hpd1);
coll.Add(hpd2);
// CopyTo
HttpParameterDescription[] arr = new HttpParameterDescription[2];
coll.CopyTo(arr, 0);
Assert.AreSame(hpd1, arr[0], "CopyTo[0] failed");
Assert.AreSame(hpd2, arr[1], "CopyTo[1] failed");
// CopyTo negative tests
ExceptionAssert.ThrowsArgumentNull(
"CopyTo throws argument null for null array",
"array",
() => coll.CopyTo(null, 0)
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"CopyTo should throw for negative index",
() => coll.CopyTo(arr, -1),
"arrayIndex"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"CopyTo should throw for too large an index",
() => coll.CopyTo(arr, 2),
"arrayIndex"
);
}
public void HttpParameterDescriptionCollection_Synchronized_Incomplete_Indexer()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od, isOutputCollection: false);
HttpParameterDescription hpd = hod.InputParameters[0];
// Zap both inputs and outputs
MessageDescription mdInput = od.Messages[0];
MessageDescription mdOutput = od.Messages[1];
od.Messages.Clear();
// Verify the HOD sees an empty set
Assert.AreEqual(0, hod.InputParameters.Count, "Expected zero input parameters");
// Verify our local collection sees an empty set
Assert.AreEqual(0, hpdColl.Count, "Expected zero elements in local collection");
// Expect ArgumentOutOfRangeException using get indexer
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Expected ArgumentOutOfRangeException indexing into missing inputs",
() => hpd = hod.InputParameters[0]
);
// Same exception indexing our local collection
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Expected ArgumentOutOfRangeException indexing into missing inputs",
() => hpd = hpdColl[0]
);
// Expect ArgumentOutOfRangeException using set indexer on InputParameters
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Expected ArgumentOutOfRangeException indexing into missing inputs",
() => hod.InputParameters[0] = hpd
);
// Same exception setting on our local collection
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Expected ArgumentOutOfRangeException indexing into missing inputs",
() => hpdColl[0] = hpd
);
// Add back a real input MessageDescription and verify collections have content again
od.Messages.Add(mdInput);
Assert.AreEqual(2, hod.InputParameters.Count, "HOD.InputParameters did not update when added MessageDescription");
Assert.AreEqual(2, hpdColl.Count, "HODColl.Count did not update when added MessageDescription");
// The indexer get should work again
HttpParameterDescription hpd1 = hpdColl[0];
Assert.IsNotNull(hpd1, "Unexpected null reindexing collection");
hpd1 = hod.InputParameters[0];
Assert.IsNotNull(hpd1, "Unexpected null reindexing InputParameters");
// And so should the setter indexer
hpdColl[0] = hpd;
hod.InputParameters[0] = hpd;
}
public void HttpParameterDescriptionCollection_Synchronized_Incomplete_Implements_Clear()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
od.Messages.Clear();
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od, isOutputCollection: false);
hpdColl.Clear();
Assert.AreEqual(0, hpdColl.Count, "Clear failed");
}
public void HttpParameterDescriptionCollection_Unsynchronized_Contains()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
coll.Add(hpd1);
coll.Add(hpd2);
// Contains
Assert.IsTrue(coll.Contains(hpd1), "Contains[0] incorrect");
Assert.IsTrue(coll.Contains(hpd2), "Contains[1] incorrect");
Assert.IsFalse(coll.Contains(hpd3), "Contains[none] incorrect");
// Contains negative
ExceptionAssert.ThrowsArgumentNull(
"IndexOf with null should throw",
"item",
() => coll.Contains(null));
}
public void HttpParameterDescriptionCollection_Synchronized_Incomplete_IndexOf()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od, isOutputCollection: false);
HttpParameterDescription hpd = hod.InputParameters[0];
Assert.AreEqual(0, hpdColl.IndexOf(hpd), "Prove IndexOf works prior to clearing");
// Zap both inputs and outputs
MessageDescription mdInput = od.Messages[0];
MessageDescription mdOutput = od.Messages[1];
od.Messages.Clear();
// Verify the HOD sees an empty set
Assert.AreEqual(0, hod.InputParameters.Count, "Expected zero input parameters");
Assert.AreEqual(0, hpdColl.Count, "Expected zero elements in local collection");
// Verify IndexOf cannot find it in either collection
Assert.AreEqual(-1, hod.InputParameters.IndexOf(hpd), "InputParameters.IndexOf should not have found it");
Assert.AreEqual(-1, hpdColl.IndexOf(hpd), "HPDColl.IndexOf should not have found it");
// Add back a real input MessageDescription and verify collections have content again
od.Messages.Add(mdInput);
Assert.AreEqual(0, hod.InputParameters.IndexOf(hpd), "InputParameters.IndexOf should have found it");
Assert.AreEqual(0, hpdColl.IndexOf(hpd), "HPDColl.IndexOf should have found it");
}
public void HttpParameterDescriptionCollection_Unsynchronized_Indexer()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
HttpParameterDescription hpdTemp = null;
coll.Add(hpd1);
coll.Add(hpd2);
// Indexer get
Assert.AreEqual(2, coll.Count, "Count incorrect");
Assert.AreSame(hpd1, coll[0], "Indexer[0] incorrect");
Assert.AreSame(hpd2, coll[1], "Indexer[1] incorrect");
// Indexer get negative
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Indexer should throw for too large index",
() => hpdTemp = coll[2],
"index"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Indexer should throw for negative index",
() => hpdTemp = coll[-1],
"index"
);
// Indexer set
coll[1] = hpd3;
Assert.AreSame(hpd3, coll[1], "Indexer set failed");
// Indexer set null item
ExceptionAssert.ThrowsArgumentNull(
"Indexer set with null should throw",
"value",
() => coll[0] = null);
// Indexer set negative
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Indexer should throw for too large index",
() => coll[5] = hpd2,
"index"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Indexer should throw for negative index",
() => coll[-1] = hpd2,
"index"
);
}
public void HttpParameterDescriptionCollection_Unsynchronized_Implements_Clear()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
coll.Add(hpd1);
coll.Add(hpd2);
// Clear
coll.Clear();
Assert.AreEqual(0, coll.Count, "Clear failed");
}
public void HttpParameterDescriptionCollection_Synchronized_Collection_Throws_New_Mock_HttpParameterDescriptions()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
MessagePartDescriptionCollection mpdColl = od.Messages[0].Body.Parts;
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od, isOutputCollection: false);
Assert.IsFalse(hpdColl.IsReadOnly, "Collection should not be readonly");
// Create a new HPD from simple types
HttpParameterDescription hpd = new HttpParameterDescription()
{
Name = "MockHpd",
Namespace = "MockHpdNS",
Index = 2,
ParameterType = this.GetType()
};
ExceptionAssert.ThrowsInvalidOperation(
"Should throw if attempt to add unsynchronized item to synchronized collection",
() => hpdColl.Add(hpd));
ExceptionAssert.ThrowsInvalidOperation(
"Should throw if attempt to insert unsynchronized item to synchronized collection",
() => hpdColl.Insert(0, hpd));
ExceptionAssert.ThrowsInvalidOperation(
"Should throw if attempt to test contains of unsynchronized item to synchronized collection",
() => hpdColl.Contains(hpd));
ExceptionAssert.ThrowsInvalidOperation(
"Should throw if attempt to test contains of unsynchronized item to synchronized collection",
() => hpdColl.IndexOf(hpd));
}
public void HttpParameterDescriptionCollection_Unsynchronized_GetEnumerator()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
coll.Add(hpd1);
coll.Add(hpd2);
// GetEnumerator
IEnumerator<HttpParameterDescription> ie = coll.GetEnumerator();
Assert.IsNotNull(ie, "GetEnumerator failed");
object[] items = EnumeratorToArray(ie);
AssertSame(coll, items, "Generic enumerator");
// Non-generic GetEnumerator
IEnumerator iec = ((IEnumerable)coll).GetEnumerator();
Assert.IsNotNull(iec, "GetEnumerator failed");
items = EnumeratorToArray(iec);
AssertSame(coll, items, "Non-generic enumerator");
}
public void HttpParameterDescriptionCollection_Ctor_Empty_List()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection(Enumerable.Empty<HttpParameterDescription>().ToList());
Assert.AreEqual(0, coll.Count, "Expected empty list to init to empty collection");
}
public void HttpParameterDescriptionCollection_Synchronized_Incomplete_CopyTo()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od, isOutputCollection: false);
HttpParameterDescription hpd = hod.InputParameters[0];
Assert.IsTrue(hpdColl.Contains(hpd), "Prove Contains works prior to clearing");
// Zap both inputs and outputs
MessageDescription mdInput = od.Messages[0];
MessageDescription mdOutput = od.Messages[1];
od.Messages.Clear();
HttpParameterDescription[] arr = new HttpParameterDescription[2];
// CopyTo should throw ArgumentOutOfRange for any copy request
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Expected ArgumentOutOfRangeException on empty Messages",
() => hpdColl.CopyTo(arr, 0),
"arrayIndex"
);
od.Messages.Add(mdInput);
hpdColl.CopyTo(arr, 0);
Assert.AreEqual(hpd.MessagePartDescription, arr[0].MessagePartDescription, "Copy did not yield expected instance");
}
public void HttpParameterDescriptionCollection_Ctor_Throws_Null_Descriptions()
{
ExceptionAssert.ThrowsArgumentNull(
"Null list of descriptions should throw",
"descriptions",
() =>
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection(descriptions: null);
});
}
public void HttpParameterDescriptionCollection_Synchronized_Incomplete_Implements_Contains()
{
OperationDescription od = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
HttpOperationDescription hod = od.ToHttpOperationDescription();
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od, isOutputCollection: false);
HttpParameterDescription hpd = hod.InputParameters[0];
Assert.IsTrue(hpdColl.Contains(hpd), "Prove Contains works prior to clearing");
// Zap both inputs and outputs
MessageDescription mdInput = od.Messages[0];
MessageDescription mdOutput = od.Messages[1];
od.Messages.Clear();
// Verify Contains cannot find it in either collection
Assert.IsFalse(hod.InputParameters.Contains(hpd), "InputParameters.Contains should not have found it");
Assert.IsFalse(hpdColl.Contains(hpd), "HPDColl.Contains should not have found it");
// Add back a real input MessageDescription and verify collections have content again
od.Messages.Add(mdInput);
Assert.IsTrue(hod.InputParameters.Contains(hpd), "InputParameters.Contains should have found it");
Assert.IsTrue(hpdColl.Contains(hpd), "HPDColl.Contains should have found it");
}
public void HttpParameterDescriptionCollection_Unsynchronized_RemoveAt()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
coll.Add(hpd1);
coll.Add(hpd2);
// RemoveAt
coll.Add(hpd3);
Assert.AreEqual(3, coll.Count, "Add failed");
Assert.IsTrue(coll.Contains(hpd3), "Contains after add failed");
coll.RemoveAt(2);
Assert.AreEqual(2, coll.Count, "RemoveAt count failed");
Assert.IsFalse(coll.Contains(hpd3), "RemoveAt+Contains failed");
// RemoveAt negative
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"RemoveAt should throw for negative index",
() => coll.RemoveAt(-1),
"index"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"RemoveAt should throw for too large index",
() => coll.RemoveAt(3),
"index"
);
}
public void HttpParameterDescriptionCollection_Unsynchronized_IndexOf()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
coll.Add(hpd1);
coll.Add(hpd2);
// IndexOf
Assert.AreEqual(0, coll.IndexOf(hpd1), "IndexOf[0] incorrect");
Assert.AreEqual(1, coll.IndexOf(hpd2), "IndexOf[1] incorrect");
Assert.AreEqual(-1, coll.IndexOf(hpd3), "IndexOf[none] incorrect");
// IndexOf negative
ExceptionAssert.ThrowsArgumentNull(
"IndexOf with null should throw",
"item",
() => coll.IndexOf(null));
}
public void HttpParameterDescriptionCollection_Default_Ctor()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
Assert.AreEqual(0, coll.Count, "Expected default ctor to init to empty collection");
}
public void HttpParameterDescriptionCollection_Synchronized_Indexer()
{
OperationDescription od1 = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
OperationDescription od2 = GetOperationDescription(typeof(MockService3), "SampleMethod");
MessagePartDescriptionCollection mpdColl = od1.Messages[0].Body.Parts;
Assert.AreEqual(2, mpdColl.Count, "MessagePartDescriptionCollection should show 2 existing input parameters");
MessagePartDescriptionCollection mpdColl2 = od2.Messages[0].Body.Parts;
Assert.AreEqual(1, mpdColl2.Count, "MessagePartDescriptionCollection 2 should show 1 existing input parameters");
// Pull out individual parts to test synching at item level
MessagePartDescription mpd1 = mpdColl[0];
MessagePartDescription mpd2 = mpdColl[1];
// Use a MPD from a 2nd collection so we can add and remove it
MessagePartDescription mpd3 = mpdColl2[0];
// This ctor creates the synchronized form of the collection. It should immediately reflect
// the state of the MPD collection
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od1, isOutputCollection: false);
Assert.IsNotNull(hpdColl, "Failed to create HttpParameterDescriptionCollection");
Assert.AreEqual(2, hpdColl.Count, "HttpParameterDescriptionCollection should show 2 existing input parameters");
// Extension method creates synched version of HPD from MPD's
HttpParameterDescription hpd1 = mpd1.ToHttpParameterDescription();
HttpParameterDescription hpd2 = mpd2.ToHttpParameterDescription();
// Ensure the extension method created HPD's that point to the idential MPD
Assert.AreEqual(mpd1, hpd1.MessagePartDescription, "HttParameterDescription 1 linked to wrong MessagePartDescription");
Assert.AreEqual(mpd2, hpd2.MessagePartDescription, "HttParameterDescription 2 linked to wrong MessagePartDescription");
// Keep one from 2nd collection
HttpParameterDescription hpd3 = mpd3.ToHttpParameterDescription();
HttpParameterDescription hpdTemp = null;
// Indexer get (note this verifies HPD indexer redirects to original MPD coll
Assert.AreEqual(2, hpdColl.Count, "Count incorrect");
Assert.AreSame(hpd1.MessagePartDescription, hpdColl[0].MessagePartDescription, "Indexer[0] incorrect");
Assert.AreSame(hpd2.MessagePartDescription, hpdColl[1].MessagePartDescription, "Indexer[1] incorrect");
// Indexer get negative
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Indexer should throw for negative index",
() => hpdTemp = hpdColl[2],
"index"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Indexer should throw for negative index",
() => hpdTemp = hpdColl[-1],
"index"
);
// Indexer set
hpdColl[1] = hpd3;
Assert.AreEqual(2, hpdColl.Count, "Index set should have not affected count");
Assert.AreSame(hpd3.MessagePartDescription, hpdColl[1].MessagePartDescription, "Indexer[1] set incorrect");
}
public void HttpParameterDescriptionCollection_Unsynchronized_Insert()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
// Insert semamtics allow index==Count. Verify.
coll.Insert(0, hpd1);
coll.Insert(1, hpd2);
// Now really insert between
coll.Insert(1, hpd3);
Assert.AreEqual(3, coll.Count, "Insert failed");
Assert.AreSame(hpd3, coll[1], "Insert went to wrong spot");
Assert.AreSame(hpd2, coll[2], "Insert did not move items");
// Insert negative
ExceptionAssert.ThrowsArgumentNull(
"Insert throws argument null for null item",
"item",
() => coll.Insert(0, null)
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Insert should throw for negative index",
() => coll.Insert(-1, hpd3),
"index"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"Insert should throw for too large index",
() => coll.Insert(4, hpd3),
"index"
);
}
public void HttpParameterDescriptionCollection_Synchronized_IndexOf()
{
OperationDescription od1 = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
OperationDescription od2 = GetOperationDescription(typeof(MockService3), "SampleMethod");
MessagePartDescriptionCollection mpdColl = od1.Messages[0].Body.Parts;
Assert.AreEqual(2, mpdColl.Count, "MessagePartDescriptionCollection should show 2 existing input parameters");
MessagePartDescriptionCollection mpdColl2 = od2.Messages[0].Body.Parts;
Assert.AreEqual(1, mpdColl2.Count, "MessagePartDescriptionCollection 2 should show 1 existing input parameters");
// Pull out individual parts to test synching at item level
MessagePartDescription mpd1 = mpdColl[0];
MessagePartDescription mpd2 = mpdColl[1];
// Use a MPD from a 2nd collection so we can add and remove it
MessagePartDescription mpd3 = mpdColl2[0];
// This ctor creates the synchronized form of the collection. It should immediately reflect
// the state of the MPD collection
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od1, isOutputCollection: false);
Assert.IsNotNull(hpdColl, "Failed to create HttpParameterDescriptionCollection");
Assert.AreEqual(2, hpdColl.Count, "HttpParameterDescriptionCollection should show 2 existing input parameters");
// Extension method creates synched version of HPD from MPD's
HttpParameterDescription hpd1 = mpd1.ToHttpParameterDescription();
HttpParameterDescription hpd2 = mpd2.ToHttpParameterDescription();
// Ensure the extension method created HPD's that point to the idential MPD
Assert.AreEqual(mpd1, hpd1.MessagePartDescription, "HttParameterDescription 1 linked to wrong MessagePartDescription");
Assert.AreEqual(mpd2, hpd2.MessagePartDescription, "HttParameterDescription 2 linked to wrong MessagePartDescription");
// Keep one from 2nd collection
HttpParameterDescription hpd3 = mpd3.ToHttpParameterDescription();
// IndexOf
Assert.AreEqual(0, hpdColl.IndexOf(hpd1), "IndexOf[0] incorrect");
Assert.AreEqual(1, hpdColl.IndexOf(hpd2), "IndexOf[1] incorrect");
Assert.AreEqual(-1, hpdColl.IndexOf(hpd3), "IndexOf[none] incorrect");
// IndexOf negative
ExceptionAssert.ThrowsArgumentNull(
"IndexOf with null should throw",
"item",
() => hpdColl.IndexOf(null));
}
public void HttpParameterDescriptionCollection_Unsynchronized_IsReadOnly()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
Assert.IsFalse(coll.IsReadOnly, "Collection should not be readonly");
}
public void HttpParameterDescriptionCollection_Synchronized_RemoveAt()
{
OperationDescription od1 = GetOperationDescription(typeof(MockService3), "SampleInOutMethod");
OperationDescription od2 = GetOperationDescription(typeof(MockService3), "SampleMethod");
MessagePartDescriptionCollection mpdColl = od1.Messages[0].Body.Parts;
Assert.AreEqual(2, mpdColl.Count, "MessagePartDescriptionCollection should show 2 existing input parameters");
MessagePartDescriptionCollection mpdColl2 = od2.Messages[0].Body.Parts;
Assert.AreEqual(1, mpdColl2.Count, "MessagePartDescriptionCollection 2 should show 1 existing input parameters");
// Pull out individual parts to test synching at item level
MessagePartDescription mpd1 = mpdColl[0];
MessagePartDescription mpd2 = mpdColl[1];
// Use a MPD from a 2nd collection so we can add and remove it
MessagePartDescription mpd3 = mpdColl2[0];
// This ctor creates the synchronized form of the collection. It should immediately reflect
// the state of the MPD collection
HttpParameterDescriptionCollection hpdColl = new HttpParameterDescriptionCollection(od1, isOutputCollection: false);
Assert.IsNotNull(hpdColl, "Failed to create HttpParameterDescriptionCollection");
Assert.AreEqual(2, hpdColl.Count, "HttpParameterDescriptionCollection should show 2 existing input parameters");
// Extension method creates synched version of HPD from MPD's
HttpParameterDescription hpd1 = mpd1.ToHttpParameterDescription();
HttpParameterDescription hpd2 = mpd2.ToHttpParameterDescription();
// Ensure the extension method created HPD's that point to the idential MPD
Assert.AreEqual(mpd1, hpd1.MessagePartDescription, "HttParameterDescription 1 linked to wrong MessagePartDescription");
Assert.AreEqual(mpd2, hpd2.MessagePartDescription, "HttParameterDescription 2 linked to wrong MessagePartDescription");
// Keep one from 2nd collection
HttpParameterDescription hpd3 = mpd3.ToHttpParameterDescription();
// RemoveAt
hpdColl.Add(hpd3);
Assert.AreEqual(3, hpdColl.Count, "Add failed");
Assert.IsTrue(hpdColl.Contains(hpd3), "Contains after add failed");
hpdColl.RemoveAt(2);
Assert.AreEqual(2, hpdColl.Count, "RemoveAt count failed");
Assert.IsFalse(hpdColl.Contains(hpd3), "RemoveAt+Contains failed");
// RemoveAt negative
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"RemoveAt should throw for negative index",
() => hpdColl.RemoveAt(-1),
"index"
);
ExceptionAssert.Throws(
typeof(ArgumentOutOfRangeException),
"RemoveAt should throw for too large index",
() => hpdColl.RemoveAt(3),
"index"
);
}
public void HttpParameterDescriptionCollection_Unsynchronized_Remove()
{
HttpParameterDescriptionCollection coll = new HttpParameterDescriptionCollection();
HttpParameterDescription hpd1 = new HttpParameterDescription()
{
Name = "First",
Namespace = "FirstNS",
Index = 0,
ParameterType = typeof(string)
};
HttpParameterDescription hpd2 = new HttpParameterDescription()
{
Name = "Second",
Namespace = "SecondNS",
Index = 1,
ParameterType = typeof(int)
};
HttpParameterDescription hpd3 = new HttpParameterDescription()
{
Name = "Third",
Namespace = "ThirdNS",
Index = 2,
ParameterType = typeof(double)
};
coll.Add(hpd1);
coll.Add(hpd2);
// Remove
coll.Remove(hpd3);
Assert.AreEqual(2, coll.Count, "Remove failed");
Assert.IsFalse(coll.Contains(hpd3), "Remove still shows contains");
// Remove negative
Assert.IsFalse(coll.Remove(hpd3), "Redundant remove should have returned false");
ExceptionAssert.ThrowsArgumentNull(
"Remove throws argument null for null item",
"item",
() => coll.Remove(null)
);
}
