private void Insert(int index, string key, UnitTestItem value)
{
if (count == keys.Length)
EnsureCapacity(count + 1);
if (index < count)
{
Array.Copy(keys, index, keys, index + 1, count - index);
Array.Copy(values, index, values, index + 1, count - index);
}
keys[index] = key;
values[index] = value;
count++;
version++;
}
/// <summary>
/// Adds a HtmlFormTag to a HtmlUnitTestReport.
/// </summary>
/// <param name="parentRow"> The TestItemRow.</param>
/// <param name="report"> The HtmlUnitTestReport type.</param>
/// <param name="unitTestItem"> The UnitTestItem type.</param>
private void AddFormTag(HtmlUnitTestReport.TestItemRow parentRow,HtmlUnitTestReport report,UnitTestItem unitTestItem)
{
HtmlUnitTestReport.FormRow row = report.Form.NewFormRow();
if ( unitTestItem.Form != null )
{
row.Action = unitTestItem.Form.Action;
row.Enctype = unitTestItem.Form.Enctype;
row.Method = unitTestItem.Form.Method;
row.Name = unitTestItem.Form.Name;
row.SetParentRow(parentRow);
report.Form.AddFormRow(row);
}
}
/// <summary>
/// Removes the element at the specified index of the <b>UnitTestFormCollection</b>.
/// </summary>
/// <param name="index">The zero-based index of the element to remove.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="index"/> is outside the range of valid indices for the <see cref="UnitTestFormCollection"/>.
/// </exception>
/// <exception cref="NotSupportedException">
/// <para>The <see cref="UnitTestFormCollection"/> is read-only.</para>
/// <para>-or-</para>
/// <para>The <b>UnitTestFormCollection</b> has a fixed size.</para>
/// </exception>
/// <remarks>
/// <para>The index sequence is based on the sort sequence. When an element is added,
/// it is inserted into <see cref="UnitTestFormCollection"/> in the correct sort order, and
/// the indexing adjusts accordingly. When an element removed, the indexing also adjusts
/// accordingly. Therefore, the index of a specific key-and-value pair might change as
/// elements are added or removed from the <see cref="UnitTestFormCollection"/>.</para>
/// <para>In collections of contiguous elements, such as lists, the elements that
/// follow the removed element move up to occupy the vacated spot. If the collection is
/// indexed, the indices of the elements that are moved are also updated.</para>
/// </remarks>
public virtual void RemoveAt(int index)
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index", index, "The index is outside the range of valid indices.");
count--;
if (index < count)
{
Array.Copy(keys, index + 1, keys, index, count - index);
Array.Copy(values, index + 1, values, index, count - index);
}
// We can't set the deleted entries equal to null, because they might be value types.
// Instead, we'll create empty single-element arrays of the right type and copy them
// over the entries we want to erase.
string[] tempKey = new string[1];
UnitTestItem[] tempVal = new UnitTestItem[1];
Array.Copy(tempKey, 0, keys, count, 1);
Array.Copy(tempVal, 0, values, count, 1);
version++;
}
/// <summary>
/// Replaces the value at a specific index in the <b>UnitTestFormCollection</b>.
/// </summary>
/// <param name="index">The zero-based index at which to save <paramref name="value"/>.</param>
/// <param name="value">The <see cref="UnitTestItem"/> to save into the <see cref="UnitTestFormCollection"/>.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="index"/> is outside the range of valid indices for the <see cref="UnitTestFormCollection"/>.
/// </exception>
/// <remarks>
/// <para>The index sequence is based on the sort sequence. When an element is added,
/// it is inserted into <see cref="UnitTestFormCollection"/> in the correct sort order, and
/// the indexing adjusts accordingly. When an element removed, the indexing also adjusts
/// accordingly. Therefore, the index of a specific key-and-value pair might change as
/// elements are added or removed from the <see cref="UnitTestFormCollection"/>.</para>
/// </remarks>
public virtual void SetByIndex(int index, UnitTestItem value)
{
if (index < 0 || index >= count)
throw new ArgumentOutOfRangeException("index", index, "The index is outside the range of valid indices.");
values[index] = value;
version++;
}
/// <summary>
/// Determines whether the <b>UnitTestFormCollection</b> contains a specific value.
/// </summary>
/// <param name="value">The value to locate in the <see cref="UnitTestFormCollection"/>.</param>
/// <returns>
/// <b>true</b> if the <see cref="UnitTestFormCollection"/> contains an element with the specified
/// <paramref name="value"/>; otherwise, <b>false</b>.
/// </returns>
public virtual bool ContainsValue(UnitTestItem value)
{
return (IndexOfValue(value) >= 0);
}
/// <summary>
/// Returns the zero-based index of the first occurrence of the specified value in
/// the <b>UnitTestFormCollection</b>.
/// </summary>
/// <param name="value">The value to locate in the <see cref="UnitTestFormCollection"/>.</param>
/// <returns>
/// The zero-based index of <paramref name="value"/>, if <paramref name="value"/> is found in
/// the <see cref="UnitTestFormCollection"/>; otherwise, -1.
/// </returns>
/// <remarks>
/// <para>The index sequence is based on the sort sequence. When an element is added,
/// it is inserted into <see cref="UnitTestFormCollection"/> in the correct sort order, and
/// the indexing adjusts accordingly. When an element removed, the indexing also adjusts
/// accordingly. Therefore, the index of a specific key-and-value pair might change as
/// elements are added or removed from the <see cref="UnitTestFormCollection"/>.</para>
/// <para>The values of the elements of the <see cref="UnitTestFormCollection"/> are compared to the
/// specified value using the Equals method.</para>
/// <para>This method uses a linear search; therefore, the average execution time is
/// proportional to <see cref="UnitTestFormCollection.Count"/>.</para>
/// </remarks>
public virtual int IndexOfValue(UnitTestItem value)
{
return Array.IndexOf(values, value, 0, count);
}
public virtual int IndexOf(UnitTestItem value)
{
return list.IndexOfValue(value);
}
public virtual void Reset()
{
if (version != list.version)
throw new InvalidOperationException("The collection was modified - enumeration cannot continue.");
// We can't set the entries equal to null, because they might be value types.
// Instead, we'll create empty single-element arrays of the right type and copy them
// over the entries we want to erase.
string[] tempKey = new string[1];
UnitTestItem[] tempVal = new UnitTestItem[1];
key = tempKey[0];
value = tempVal[0];
currentValid = false;
index = startIndex;
}
public override void SetByIndex(int index, UnitTestItem value)
{
lock (root)
list.SetByIndex(index, value);
}
public virtual bool Contains(UnitTestItem value)
{
return list.ContainsValue(value);
}
public override int IndexOfValue(UnitTestItem value)
{
lock (root)
return list.IndexOfValue(value);
}
public override bool ContainsValue(UnitTestItem value)
{
lock (root)
return list.ContainsValue(value);
}
public override void Add(string key, UnitTestItem value)
{
lock (root)
list.Add(key, value);
}
/// <summary>
/// Adds the tests to the report.
/// </summary>
/// <param name="parentRow"> The TestItemRow.</param>
/// <param name="report"> The HtmlUnitTestReport type.</param>
/// <param name="unitTestItem"> The UnitTestItem type.</param>
private void AddTest(HtmlUnitTestReport.TestItemRow parentRow, HtmlUnitTestReport report, UnitTestItem unitTestItem)
{
HtmlUnitTestReport.TestsRow row = report.Tests.NewTestsRow();
Test t = unitTestItem.Tests.GetByIndex(unitTestItem.SelectedTestIndex);
if ( t.Arguments is BufferOverflowTesterArgs )
{
row.BufferLength = ((BufferOverflowTesterArgs)t.Arguments).BufferLength;
}
if ( t.Arguments is DataTypesTesterArgs )
{
Ecyware.GreenBlue.Engine.DataType dt = ((DataTypesTesterArgs)t.Arguments).SelectedDataType;
switch ( dt )
{
case Ecyware.GreenBlue.Engine.DataType.Character:
row.DataTypeTest = "Character";
break;
case Ecyware.GreenBlue.Engine.DataType.Null:
row.DataTypeTest = "Null String";
break;
case Ecyware.GreenBlue.Engine.DataType.Numeric:
row.DataTypeTest = "Numeric";
break;
}
}
if ( t.Arguments is SqlInjectionTesterArgs )
{
string testValue = ((SqlInjectionTesterArgs)t.Arguments).SqlValue;
row.TestValue = testValue;
}
if ( t.Arguments is XssInjectionTesterArgs )
{
string testValue = ((XssInjectionTesterArgs)t.Arguments).XssValue;
row.TestValue = testValue;
}
row.PostData = t.Arguments.PostData;
row.Name = t.Name;
switch ( t.UnitTestDataType )
{
case UnitTestDataContainer.Cookies:
row.PostDataContainer = "Cookies";
break;
case UnitTestDataContainer.HtmlFormTag:
row.PostDataContainer = "Form";
break;
case UnitTestDataContainer.NoPostData:
row.PostDataContainer = "Url";
break;
case UnitTestDataContainer.PostDataHashtable:
row.PostDataContainer = "Post Data";
break;
}
switch ( t.TestType )
{
case UnitTestType.BufferOverflow:
row.TestType = "Buffer overflow";
break;
case UnitTestType.DataTypes:
row.TestType = "Data type";
break;
case UnitTestType.Predefined:
row.TestType = "Predefined";
break;
case UnitTestType.SafeTest:
row.TestType = "Safe Test";
break;
case UnitTestType.SqlInjection:
row.TestType = "SQL Injection";
break;
case UnitTestType.XSS:
row.TestType = "XSS";
break;
}
row.SetParentRow(parentRow);
report.Tests.AddTestsRow(row);
}
/// <summary>
/// Adds an element with the specified key and value to the <b>UnitTestFormCollection</b>.
/// </summary>
/// <param name="key">The key of the element to add.</param>
/// <param name="value">The value of the element to add.</param>
/// <exception cref="ArgumentNullException">The <paramref name="key"/> is a null reference.</exception>
/// <exception cref="ArgumentException">
/// <para>An element with the specified <paramref name="key"/> already exists in the <see cref="UnitTestFormCollection"/>.</para>
/// <para>-or-</para>
/// <para>The <b>UnitTestFormCollection</b> is set to use the <see cref="IComparable"/> interface,
/// and <paramref name="key"/> does not implement the <b>IComparable</b> interface.</para>
/// </exception>
/// <exception cref="InvalidOperationException">The comparer throws an exception.</exception>
/// <exception cref="NotSupportedException">
/// <para>The <see cref="UnitTestFormCollection"/> is read-only.</para>
/// <para>-or-</para>
/// <para>The <b>UnitTestFormCollection</b> has a fixed size.</para>
/// </exception>
public virtual void Add(string key, UnitTestItem value)
{
if (Object.ReferenceEquals(key, null)) // avoids compiler error for null check on value type
throw new ArgumentNullException("key", "The key cannot be null.");
int index = Array.BinarySearch(keys, 0, count, key, comparer);
if (index >= 0)
throw new ArgumentException(String.Format("Item has already been added. Key being added: \"{0}\".", key));
Insert(~index, key, value);
}
/// <summary>
/// Adds a UnitTestItem to a HtmlUnitTestReport.
/// </summary>
/// <param name="parentRow"> The TestItemRow.</param>
/// <param name="report"> The HtmlUnitTestReport type.</param>
/// <param name="unitTestItem"> The UnitTestItem type.</param>
/// <returns> A TestItemRow type.</returns>
private HtmlUnitTestReport.TestItemRow AddTestItemRow(HtmlUnitTestReport.ResponseDocumentRow parentRow,HtmlUnitTestReport report, UnitTestItem unitTestItem)
{
HtmlUnitTestReport.TestItemRow row = report.TestItem.NewTestItemRow();
row.SetParentRow(parentRow);
report.TestItem.AddTestItemRow(row);
return row;
}
/// <summary>
/// Runs the command.
/// </summary>
public void Run()
{
this._isRunning = true;
postRequest = new PostForm();
getRequest = new GetForm();
postRequest.EndHttp += new ResponseCallbackDelegate(httpResponse_EndHttp);
getRequest.EndHttp += new ResponseCallbackDelegate(httpResponse_EndHttp);
reports = new ArrayList();
TestCollection tests = GetTests();
UnitTestItem testItem = new UnitTestItem(FormTag, tests);
int availableTests = tests.Count;
bool lastItem = false;
#region Run each test in UnitTestItem
// run each test in Form
foreach (DictionaryEntry de in tests)
{
Test test = (Test)de.Value;
// apply test to form
HtmlFormTag filledForm = ApplyTestToForm(test, FormTag.CloneTag());
// set current test index
testItem.SelectedTestIndex = testItem.Tests.IndexOfValue(test);
// resolve uri
string url = UriResolver.ResolveUrl(this.Url,filledForm.Action);
// convert to array list
// TODO: Send HTML Source for bypassing fields. Will be needed for ASP.NET testing.
ArrayList al = parser.GetArrayList(filledForm);
// set posted data
StringBuilder postDataBuffer = new StringBuilder();
postDataBuffer.Append("?");
for (int k=0;k<al.Count;k++)
{
postDataBuffer.Append(al[k]);
postDataBuffer.Append("&");
}
test.Arguments.PostData = postDataBuffer.ToString();
// set last item flag
if ( availableTests == 1)
{
lastItem = true;
}
CookieManager cookieManager = new CookieManager();
CookieCollection cookies = cookieManager.GetCookies(new Uri(url));
HttpState httpRequestState = new HttpState();
httpRequestState.TestItem = testItem.Clone();
httpRequestState.IsLastItem = lastItem;
if ( filledForm.Method.ToLower(System.Globalization.CultureInfo.InvariantCulture) == "get" )
{
getRequest.StartAsyncHttpGet(
url,
this.ProtocolProperties,
al,
cookies,
httpRequestState,
false);
}
else
{
postRequest.StartAsyncHttpPost(
url,
this.ProtocolProperties,
al,
cookies,
httpRequestState);
}
availableTests--;
}
#endregion
}