/// <summary>
/// Writes the current context to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <b>XmlWriter</b> to which you want to write the current context.</param>
/// <param name="xmlNamespace">The XML namespace used to qualify prefixed syndication extension elements and attributes.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="xmlNamespace"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="xmlNamespace"/> is an empty string.</exception>
public void WriteTo(XmlWriter writer, string xmlNamespace)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
Guard.ArgumentNotNullOrEmptyString(xmlNamespace, "xmlNamespace");
//------------------------------------------------------------
// Write current extension details to the writer
//------------------------------------------------------------
if (ItemsPerPage != null)
{
writer.WriteElementString("itemsPerPage", xmlNamespace, ItemsPerPage.ToString());
}
if (TotalResults != null)
{
writer.WriteElementString("totalResults", xmlNamespace, TotalResults.ToString());
}
if (StartIndex != null)
{
writer.WriteElementString("startIndex", xmlNamespace, StartIndex.ToString());
}
}
public bool Equals(SearchResultOfContentItemPublicContract input)
{
if (input == null)
{
return(false);
}
return
((
Results == input.Results ||
(Results != null && Results.SequenceEqual(input.Results))
) &&
(
TotalResults == input.TotalResults ||
(TotalResults.Equals(input.TotalResults))
) &&
(
HasMore == input.HasMore ||
(HasMore != null && HasMore.Equals(input.HasMore))
) &&
(
Query == input.Query ||
(Query != null && Query.Equals(input.Query))
) &&
(
ReplacementContinuationToken == input.ReplacementContinuationToken ||
(ReplacementContinuationToken != null && ReplacementContinuationToken.Equals(input.ReplacementContinuationToken))
) &&
(
UseTotalResults == input.UseTotalResults ||
(UseTotalResults != null && UseTotalResults.Equals(input.UseTotalResults))
));
}
private void WriteHeaders()
{
_response.Headers.Add("Raven-Result-Etag", ResultEtag.ToString());
_response.Headers.Add("Raven-Is-Stale", IsStale ? "true" : "false");
_response.Headers.Add("Raven-Index", IndexName);
_response.Headers.Add("Raven-Total-Results", TotalResults.ToInvariantString());
_response.Headers.Add("Raven-Index-Timestamp", IndexTimestamp.GetDefaultRavenFormat(isUtc: true));
}
private void WriteTime(TotalResults results)
{
Console.WriteLine($"Testing time:\n");
Console.WriteLine($"Total samples: {_testsSettings.TimeTest.Samples.ToString(NumFormat, CultureInfo.InvariantCulture)}\n");
foreach (var timeResult in results.TimeTestResults)
{
Console.WriteLine($"{timeResult.RngName}: {timeResult.TimeElapsedMs} ms");
}
}
public void WriteOutput(TotalResults results)
{
WriteChi(results);
Console.WriteLine("---------------------------------");
WriteMean(results);
Console.WriteLine("---------------------------------");
WriteTime(results);
Console.WriteLine("---------------------------------");
WriteStandardDeviation(results);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (Transactions != null ? Transactions.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (TotalResults != null ? TotalResults.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ IsPreviousPage.GetHashCode();
hashCode = (hashCode * 397) ^ IsNextPage.GetHashCode();
hashCode = (hashCode * 397) ^ FirstResult;
return(hashCode);
}
}
private void WriteStandardDeviation(TotalResults results)
{
Console.WriteLine($"Testing standard deviation:\n");
Console.WriteLine($"Total samples: {_testsSettings.StandardDeviationTest.Samples.ToString(NumFormat, CultureInfo.InvariantCulture)}");
Console.WriteLine($"Max value: {_testsSettings.StandardDeviationTest.Max.ToString(NumFormat, CultureInfo.InvariantCulture)}\n");
foreach (var standardDeviationResult in results.StandardDeviationTestResults)
{
Console.WriteLine($"{standardDeviationResult.RngName}: {standardDeviationResult.StandardDeviation.ToString("0.00", CultureInfo.InvariantCulture)}, "
+ $"Coefficient of variation: {(standardDeviationResult.CoefficientOfVariation * 100).ToString("0.00", CultureInfo.InvariantCulture)}%");
}
}
private void WriteMean(TotalResults results)
{
Console.WriteLine($"Testing mean:\n");
Console.WriteLine($"Total samples: {_testsSettings.MeanTest.Samples.ToString(NumFormat, CultureInfo.InvariantCulture)}");
Console.WriteLine($"Max value: {_testsSettings.MeanTest.Max.ToString(NumFormat, CultureInfo.InvariantCulture)}");
Console.WriteLine($"Expected average: {_testsSettings.MeanTest.AvgExpected.ToString(NumFormat, CultureInfo.InvariantCulture)}\n");
foreach (var meanResult in results.MeanTestResults)
{
Console.WriteLine($"{meanResult.RngName}: {meanResult.AvgCalculated}, Error = {meanResult.Error}");
}
}
private void WriteChi(TotalResults results)
{
Console.WriteLine($"Testing distribution with the Chi Square tests:\n");
Console.WriteLine($"Total draws: {_testsSettings.ChiTest.TotalDraws.ToString(NumFormat, CultureInfo.InvariantCulture)}");
Console.WriteLine($"Expected distribution: {_testsSettings.ChiTest.SampleSize.ToString(NumFormat, CultureInfo.InvariantCulture)} for each number\n");
foreach (var chiTestResult in results.ChiTestResults)
{
Console.WriteLine("---------------------------------");
Console.WriteLine($"{chiTestResult.RngName}: \n{string.Join("\n", chiTestResult.ObservedDict.OrderBy(k => k.Key))}");
Console.WriteLine($"\nPValue = {chiTestResult.PValue}");
Console.WriteLine($"Significant = {chiTestResult.IsSignificant}");
}
}
public void Run()
{
Console.WriteLine("Testing RNGs...\n");
var rnd = new Random();
var seed = rnd.Next();
var wichSeed = rnd.Next(30000);
var lehmerRng = new LehmerRng(seed);
var wichmannRng = new WichmannRng(wichSeed);
var linearConRng = new LinearConRng(seed);
var buildInRng = new BuildInRng();
var result = new TotalResults
{
ChiTestResults = new List <ChiTestResult>
{
_testRng.ChiTest(buildInRng),
_testRng.ChiTest(lehmerRng),
_testRng.ChiTest(wichmannRng),
_testRng.ChiTest(linearConRng)
},
MeanTestResults = new List <MeanTestResult>
{
_testRng.MeanTest(buildInRng),
_testRng.MeanTest(lehmerRng),
_testRng.MeanTest(wichmannRng),
_testRng.MeanTest(linearConRng)
},
TimeTestResults = new List <TimeTestResult>
{
_testRng.TimeTest(buildInRng),
_testRng.TimeTest(lehmerRng),
_testRng.TimeTest(wichmannRng),
_testRng.TimeTest(linearConRng)
},
StandardDeviationTestResults = new List <StandardDeviationTestResult>
{
_testRng.StandardDeviationTest(buildInRng),
_testRng.StandardDeviationTest(lehmerRng),
_testRng.StandardDeviationTest(wichmannRng),
_testRng.StandardDeviationTest(linearConRng)
}
};
_outputBuilder.WriteOutput(result);
Console.ReadLine();
}
public bool Equals(GetGroupsForMemberResponse input)
{
if (input == null)
{
return(false);
}
return
((
AreAllMembershipsInactive == input.AreAllMembershipsInactive ||
(AreAllMembershipsInactive != null && AreAllMembershipsInactive.SequenceEqual(input.AreAllMembershipsInactive))
) &&
(
Results == input.Results ||
(Results != null && Results.SequenceEqual(input.Results))
) &&
(
TotalResults == input.TotalResults ||
(TotalResults.Equals(input.TotalResults))
) &&
(
HasMore == input.HasMore ||
(HasMore != null && HasMore.Equals(input.HasMore))
) &&
(
Query == input.Query ||
(Query != null && Query.Equals(input.Query))
) &&
(
ReplacementContinuationToken == input.ReplacementContinuationToken ||
(ReplacementContinuationToken != null && ReplacementContinuationToken.Equals(input.ReplacementContinuationToken))
) &&
(
UseTotalResults == input.UseTotalResults ||
(UseTotalResults != null && UseTotalResults.Equals(input.UseTotalResults))
));
}
public bool Equals(PostSearchResponse input)
{
if (input == null)
{
return(false);
}
return
((
RelatedPosts == input.RelatedPosts ||
(RelatedPosts != null && RelatedPosts.SequenceEqual(input.RelatedPosts))
) &&
(
Authors == input.Authors ||
(Authors != null && Authors.SequenceEqual(input.Authors))
) &&
(
Groups == input.Groups ||
(Groups != null && Groups.SequenceEqual(input.Groups))
) &&
(
SearchedTags == input.SearchedTags ||
(SearchedTags != null && SearchedTags.SequenceEqual(input.SearchedTags))
) &&
(
Polls == input.Polls ||
(Polls != null && Polls.SequenceEqual(input.Polls))
) &&
(
RecruitmentDetails == input.RecruitmentDetails ||
(RecruitmentDetails != null && RecruitmentDetails.SequenceEqual(input.RecruitmentDetails))
) &&
(
AvailablePages == input.AvailablePages ||
(AvailablePages.Equals(input.AvailablePages))
) &&
(
Results == input.Results ||
(Results != null && Results.SequenceEqual(input.Results))
) &&
(
TotalResults == input.TotalResults ||
(TotalResults.Equals(input.TotalResults))
) &&
(
HasMore == input.HasMore ||
(HasMore != null && HasMore.Equals(input.HasMore))
) &&
(
Query == input.Query ||
(Query != null && Query.Equals(input.Query))
) &&
(
ReplacementContinuationToken == input.ReplacementContinuationToken ||
(ReplacementContinuationToken != null && ReplacementContinuationToken.Equals(input.ReplacementContinuationToken))
) &&
(
UseTotalResults == input.UseTotalResults ||
(UseTotalResults != null && UseTotalResults.Equals(input.UseTotalResults))
));
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="version"></param>
protected override void WriteElementExtensions(XmlWriter writer, string version)
{
if (TotalResults > 0)
{
writer.WriteElementString("totalResults", OpdsNamespaces.OpenSearch.Value, TotalResults.ToString(CultureInfo.InvariantCulture));
}
if (ItemsPerPage > 0)
{
writer.WriteElementString("itemsPerPage", OpdsNamespaces.OpenSearch.Value, ItemsPerPage.ToString(CultureInfo.InvariantCulture));
}
base.WriteElementExtensions(writer, version);
}
