private Trait ReadTrait(XmlReader reader, Counter<string> badTags)
{
string identifier = null;
string description = null;
string label = null;
int oppositeOpinion = 0;
int sameOpinion = 0;
string[] opposites = new string[0];
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
identifier = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "description")
{
description = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "label")
{
label = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "opposites")
{
opposites = XmlHelper.ReadList(reader, "opposite", badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "opposite_opinion")
{
oppositeOpinion = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "same_opinion")
{
sameOpinion = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "trait")
{
break;
}
}
return new Trait(identifier, label, description, sameOpinion, oppositeOpinion, opposites);
}
public void should_call_initializer_methods_in_right_order()
{
var counter = new Counter();
var bus = new TestBus();
bus.Starting += () => counter.Increment();
bus.Started += () => counter.Increment();
bus.Stopping += () => counter.Increment();
bus.Stopped += () => counter.Increment();
var testHostInitializer = new TestHostInitializer(counter);
var host = new Host();
var container = host.ContainerFactory.Invoke();
host.ContainerFactory = () =>
{
container.Configure(x =>
{
x.ForSingletonOf<IBus>().Use(bus);
x.ForSingletonOf<HostInitializer>().Add(testHostInitializer);
});
return container;
};
host.Start();
host.Stop();
testHostInitializer.CapturedContainer.ShouldEqual(container);
testHostInitializer.ConfigureContainerCounterValue.ShouldEqual(0);
testHostInitializer.BeforeStartCounterValue.ShouldEqual(0);
testHostInitializer.AfterStartCounterValue.ShouldEqual(2);
testHostInitializer.BeforeStopCounterValue.ShouldEqual(2);
testHostInitializer.AfterStopCounterValue.ShouldEqual(4);
}
public static AreaType ReadAreaType(XmlReader reader, Counter<string> badTags)
{
string type = null;
int level = 0;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "type")
{
type = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "level")
{
level = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "area")
{
break;
}
}
if (level == 0 || type == null)
throw new Exception("Area type or level not specified.");
return new AreaType(level, type);
}
public async Task<StreamSubscriptionHandle<int>> BecomeConsumer(Guid streamId, string streamNamespace, string providerToUse)
{
logger.Info("BecomeConsumer");
// new counter for this subscription
var count = new Counter();
// get stream
IStreamProvider streamProvider = GetStreamProvider(providerToUse);
var stream = streamProvider.GetStream<int>(streamId, streamNamespace);
// subscribe
StreamSubscriptionHandle<int> handle = await stream.SubscribeAsync(
(e, t) =>
{
logger.Info("Got next event {0}", e);
count.Increment();
return TaskDone.Done;
});
// track counter
consumedMessageCounts.Add(handle, count);
// return handle
return handle;
}
public async Task DeactivationTest_ClientConsumer(Guid streamGuid, string streamNamespace)
{
// get producer and consumer
var producer = GrainClient.GrainFactory.GetGrain<ISampleStreaming_ProducerGrain>(Guid.NewGuid());
var count = new Counter();
// get stream and subscribe
IStreamProvider streamProvider = GrainClient.GetStreamProvider(streamProviderName);
var stream = streamProvider.GetStream<int>(streamGuid, streamNamespace);
StreamSubscriptionHandle<int> subscriptionHandle = await stream.SubscribeAsync((e, t) => count.Increment());
// produce one message (PubSubRendezvousGrain will have one consumer and one producer)
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName);
await producer.Produce();
Assert.AreEqual(count.Value, 1, "Client consumer grain has not received stream message");
//TODO: trigger deactivation programmatically
await Task.Delay(TimeSpan.FromMilliseconds(130000)); // wait for the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain to be deactivated
// deactivating PubSubRendezvousGrain and SampleStreaming_ProducerGrain during the same GC cycle causes a deadlock
// resume producing after the PubSubRendezvousGrain and the SampleStreaming_ProducerGrain grains have been deactivated:
await producer.BecomeProducer(streamGuid, streamNamespace, streamProviderName).WithTimeout(Timeout, "BecomeProducer is hung due to deactivation deadlock");
await producer.Produce().WithTimeout(Timeout, "Produce is hung due to deactivation deadlock");
Assert.AreEqual(count.Value, 2, "Client consumer grain did not receive stream messages after PubSubRendezvousGrain and SampleStreaming_ProducerGrain reactivation");
}
public void should_increment_counter_by_given_delta() {
var counter = new Counter(new MetricConfig("counter1"));
counter.Increment(15);
double count = Testing.Sync(counter, counter.GetMeasure, counter.context_);
Assert.That(count, Is.EqualTo(15));
}
private void PrintWord(string word, Counter counter)
{
counter.Increment();
if (counter.Value > 1)
_returnValue = word + " " + counter.Value + " times!";
else
_returnValue = word;
}
public void Increment()
{
Counter target = new Counter ();
Assert.AreEqual (0, target.Value(), "The initial Value was not zero");
target.Increment ();
Assert.AreEqual (1, target.Value(), "The incremented Value was not 1");
}
public void SingleThread()
{
Counter c = new Counter();
ThreadManager tt = new ThreadManager();
tt.AddThreadAction(
delegate
{
c.Increment();
});
tt.RunBehavior=ThreadRunBehavior.RunUntilAllThreadsFinish;
tt.StartAllThreads(500);
Assert.IsTrue(tt.LastRunTime<tt.TimeOut);
}
public void SingleThreadForSpecifiedTimeStrategy()
{
Counter c = new Counter();
ThreadManager tt = new ThreadManager();
tt.AddThreadAction(
delegate
{
c.Increment();
});
tt.RunBehavior = ThreadRunBehavior.RunForSpecificTime;
tt.StartAllThreads(500);
Assert.IsTrue(tt.LastRunTime >499,"runtime was "+ tt.LastRunTime);
}
static void Main(string[] args)
{
Counter c = new Counter(30);
c.Buzz += ((sender,e) => Console.WriteLine("BUZZ"));
c.Fizz += ((sender, e) => Console.WriteLine("FIZZ"));
c.End += ((sender, e) => {
Console.WriteLine("End !!");
Console.Read();
Environment.Exit(0);
});
c.Other += ((sender,e) => Console.WriteLine(e.Value));
Console.WriteLine("press 'a'");
while (Console.ReadKey(true).KeyChar == 'a')
{
c.Increment();
}
}
private FeatData ReadFeat(XmlReader reader, Counter<string> badTags)
{
string identifier = null;
string name = null;
string imageName = null;
List<FeatType> types = new List<FeatType>();
EffectParams effectParams = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
identifier = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "name")
{
name = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "image_name")
{
imageName = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "type")
{
FeatType type = (FeatType)Enum.Parse(typeof(FeatType), reader.ReadElementContentAsString());
types.Add(type);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "effect")
{
effectParams = XmlHelper.ReadEffectParams(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "feat")
{
break;
}
}
return new FeatData(identifier, name, imageName, types, effectParams);
}
public void HundredThreads()
{
Counter c = new Counter();
ThreadManager tt = new ThreadManager();
for (int i = 0; i < 100; i++)
{
tt.AddThreadAction(delegate
{
for (int j = 0; j < 10; j++)
{
c.Increment();
Thread.Sleep(new Random(j+1).Next(100,300));
}
});
}
//this test will run for 22.5 seconds
tt.RunBehavior=ThreadRunBehavior.RunForSpecificTime;
tt.StartAllThreads(22500);
}
/// <nodoc />
protected Task <T> PerformRetries <T>(OperationContext operationContext, Func <Task <T> > action, Action <int> onRetry = null, Counter?retryCounter = null, [CallerMemberName] string operationName = null)
{
var retry = 0;
return(RetryPolicy.ExecuteAsync(Wrapper, operationContext.Token));
Task <T> Wrapper()
{
if (retry > 0)
{
// Normalize operation name
operationName = operationName.Replace("Async", "").Replace("Core", "");
Tracer.Debug(operationContext, $"{Tracer.Name}.{operationName} retry #{retry}");
Tracer.TrackMetric(operationContext, $"{operationName}Retry", 1);
retryCounter?.Increment();
onRetry?.Invoke(retry);
}
retry++;
return(action());
}
}
private EffectData ReadEffect(XmlReader reader, Counter<string> badTags)
{
string identifier = null;
string name = null;
string imageName = null;
bool incapacitate = false;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
identifier = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "name")
{
name = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "image_name")
{
imageName = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "incapacitate")
{
incapacitate = reader.ReadElementContentAsBoolean();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "effect")
{
break;
}
}
return new EffectData(identifier, name, imageName, incapacitate);
}
private static IExecute ReadIfExecute(XmlReader reader, Counter<string> badTags)
{
ILogic requirements = Logic.TRUE;
IExecute thenExecute = Execute.NOOP;
IExecute elseExecute = Execute.NOOP;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "requirements")
{
requirements = ReadLogic(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "then")
{
thenExecute = ReadExecute(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "else")
{
elseExecute = ReadExecute(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "if")
{
break;
}
}
return new IfExecute(requirements, thenExecute, elseExecute);
}
private OpinionModifier ReadOpinionModifier(XmlReader reader, Counter<string> badTags)
{
string identifier = null;
string description = null;
string label = null;
int change = 0;
int duration = int.MaxValue;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
identifier = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "description")
{
description = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "label")
{
label = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "duration")
{
duration = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "opinion_change")
{
change = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "opinion_mod")
{
break;
}
}
return new OpinionModifier(identifier, label, description, duration, change);
}
private void ReadOpinionModifiers(XmlReader reader, Counter<string> badTags)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "opinion_mod")
{
OpinionModifier mod = ReadOpinionModifier(reader, badTags);
opinionModifiers.Add(mod.Identifier, mod);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "opinion_mods")
{
break;
}
}
}
public void LoadModifiersFromFile(string filename, Counter<string> badTags)
{
using (XmlReader reader = XmlReader.Create(filename))
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "prestige_mods")
{
ReadPrestigeModifiers(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "opinion_mods")
{
ReadOpinionModifiers(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
}
}
}
private Task OnNext(int e, StreamSequenceToken token, int countCapture, Counter count)
{
logger.Info("Got next event {0} on handle {1}", e, countCapture);
var contextValue = RequestContext.Get(SampleStreaming_ProducerGrain.RequestContextKey) as string;
if (!String.Equals(contextValue, SampleStreaming_ProducerGrain.RequestContextValue))
{
throw new Exception(String.Format("Got the wrong RequestContext value {0}.", contextValue));
}
count.Increment();
return TaskDone.Done;
}
private static IExecute ReadScopingLoop(XmlReader reader, Counter<string> badTags)
{
//How did we start? Used for determining when we're done.
string tag = reader.Name;
ILogic requirements = Logic.TRUE;
IExecute operation = Execute.NOOP;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "requirements")
{
requirements = ReadLogic(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "for_character")
{
operation = ReadExecute(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == tag)
{
break;
}
}
// TODO: make this more general.
if (tag == "everyone_in_room")
return new EveryoneInRoomExecute(operation, requirements);
else if (tag == "any_child")
return new AnyChildExecute(operation, requirements);
else
throw new Exception("Unexpected tag " + tag);
}
private static ILogic ReadTestEventOptionsLogic(XmlReader reader, Counter<string> badTags)
{
string id = null;
Dictionary<string, string> parameters = new Dictionary<string, string>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
id = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "parameters")
{
while (reader.MoveToNextAttribute())
{
parameters.Add(reader.Name, reader.Value);
}
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "test_event_options")
{
break;
}
}
return new TestEventOptionsLogic(id, parameters);
}
private static ILogic ReadSingleLogic(XmlReader reader, Counter<string> badTags)
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "has_information")
{
string about = reader.GetAttribute("about");
string typeName = reader.GetAttribute("type");
InformationType type = StringToInformationType(typeName);
return new HasInformationTestLogic(about, type);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "true")
{
return Logic.TRUE;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "false")
{
return Logic.FALSE;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "not")
{
return new NotLogic(ReadLogic(reader, badTags));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "and")
{
//ReadLogic will just and whatever it finds.
return ReadLogic(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "or")
{
//ReadLogic will just or whatever it finds.
return ReadOrLogic(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_earlymorning")
{
return Logic.IS_EARLYMORNING;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "has_spouse")
{
return Logic.HAS_SPOUSE;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_male")
{
return Logic.IS_MALE;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_female")
{
return Logic.IS_FEMALE;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_adult")
{
return Logic.IS_ADULT;
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_spouse_of")
{
return new IsSpouseOfLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_child_of")
{
return new IsChildOfLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "is_character")
{
return new IsCharacterLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "has_trait")
{
return new HasTraitLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "any_child")
{
return new AnyChildLogic(ReadLogic(reader, badTags));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "all_child")
{
return new AllChildLogic(ReadLogic(reader, badTags));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "prestige_rank")
{
return new PrestigeRankLogic(reader.ReadElementContentAsInt());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "job_requirements")
{
return new JobRequirementsLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "has_title_type")
{
return new HasTitleTypeLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "has_job")
{
return new HasJobLogic(reader.ReadElementContentAsString());
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "test_event_options")
{
return ReadTestEventOptionsLogic(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "set_scope")
{
string scopeName = reader.GetAttribute("name");
return new SetScopeLogic(scopeName, ReadLogic(reader, badTags));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "var_gt")
{
string varName = reader.GetAttribute("name");
return new VariableGreaterThanLogic(varName, ReadCalc(reader));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "var_lt")
{
string varName = reader.GetAttribute("name");
return new VariableLessThanLogic(varName, ReadCalc(reader));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "var_eq")
{
string varName = reader.GetAttribute("name");
return new VariableEqualLogic(varName, ReadCalc(reader));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "var_ge")
{
string varName = reader.GetAttribute("name");
return new VariableGreaterOrEqualLogic(varName, ReadCalc(reader));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "var_le")
{
string varName = reader.GetAttribute("name");
return new VariableLessOrEqualLogic(varName, ReadCalc(reader));
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "var_ne")
{
string varName = reader.GetAttribute("name");
return new VariableNotEqualLogic(varName, ReadCalc(reader));
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
return Logic.FALSE;
}
private void ReadTraits(XmlReader reader, Counter<string> badTags)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "trait")
{
Trait e = ReadTrait(reader, badTags);
traits.Add(e.Identifier, e);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "traits")
{
break;
}
}
}
private static IExecute ReadRandom(XmlReader reader, Counter<string> badTags)
{
List<IExecute> outcomes = new List<IExecute>();
List<double> chances = new List<double>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "outcome")
{
chances.Add(double.Parse(reader.GetAttribute("chance")));
outcomes.Add(ReadExecute(reader, badTags));
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "random")
{
break;
}
}
return new RandomExecute(outcomes.ToArray(), chances.ToArray());
}
private static IExecute ReadTriggerEvent(XmlReader reader, Counter<string> badTags)
{
string id = null;
string tag = reader.Name;
Dictionary<string, string> parameters = new Dictionary<string, string>();
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
id = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "parameters")
{
while (reader.MoveToNextAttribute())
{
parameters.Add(reader.Name, reader.Value);
}
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == tag)
{
break;
}
}
if (tag == "trigger_event")
return new TriggerEventExecute(id, parameters);
else
throw new Exception("Found unknown information tag: " + tag);
}
public void Parse_local_throughput(BenchmarkContext context)
{
Address.Parse("akka.tcp://sys@localhost:9091");
_parseThroughput.Increment();
}
public void TryToCreateARaceCondition()
{
Counter c = new Counter();
ThreadManager tt = new ThreadManager();
for (int i = 0; i < 100; i++)
{
tt.AddThreadAction(
delegate
{
// Console.WriteLine(Thread.CurrentThread.Name);
for (int j = 0; j < 100000; j++)
{
c.Increment();
}
});
}
tt.StartAllThreads(5000);
Assert.AreEqual(1000000,c.Count);
}
public void StopWhenTrue_StopAfterCountReaches1000()
{
Counter c = new Counter();
ThreadManager tt = new ThreadManager();
tt.RunBehavior=ThreadRunBehavior.RunForSpecificTime;
tt.AddThreadAction(delegate
{
for (int j = 0; j < 103; j++)
{
c.Increment();
}
Thread.Sleep(50);
});
tt.StopWhenTrue(delegate
{
Console.WriteLine("currently at " + c.Count);
return c.Count > 1000;
},100);
tt.StartAllThreads(10000);
Assert.Greater(c.Count,1000);
Assert.Less(c.Count,1050);
}
private Task OnError(Exception e, int countCapture, Counter error)
{
logger.Info("Got exception {0} on handle {1}", e.ToString(), countCapture);
error.Increment();
return TaskDone.Done;
}
private PrestigeModifier ReadPrestigeModifier(XmlReader reader, Counter<string> badTags)
{
string identifier = null;
string description = null;
string label = null;
int dailyChange = 0;
ILogic requirements = Logic.TRUE;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "id")
{
identifier = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "description")
{
description = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "label")
{
label = reader.ReadElementContentAsString();
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "requirements")
{
requirements = XmlHelper.ReadLogic(reader, badTags);
}
else if (reader.NodeType == XmlNodeType.Element && reader.Name == "daily_change")
{
dailyChange = reader.ReadElementContentAsInt();
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "prestige_mod")
{
break;
}
}
return new PrestigeModifier(identifier, label, description, requirements, dailyChange);
}
private void ReadPrestigeModifiers(XmlReader reader, Counter<string> badTags)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "prestige_mod")
{
PrestigeModifier mod = ReadPrestigeModifier(reader, badTags);
prestigeModifiers.Add(mod);
}
else if (reader.NodeType == XmlNodeType.Element)
{
badTags.Increment(reader.Name);
}
else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "prestige_mods")
{
break;
}
}
}
