public void TestMaxUserflowCount()
{
for (int i = 0; i < 2 * UserflowReporter.MAX_USERFLOW_COUNT; i++)
{
Crittercism.BeginUserflow(i.ToString());
}
Object[] loggedUserflows = UserflowReporter.AllUserflows();
Assert.AreEqual(UserflowReporter.UserflowCount(), UserflowReporter.MAX_USERFLOW_COUNT,
String.Format("Expecting userflowCount : {0} to be the maximum count : {1} .",
UserflowReporter.UserflowCount(),
UserflowReporter.MAX_USERFLOW_COUNT));
Assert.AreEqual(UserflowReporter.UserflowCount(), loggedUserflows.Length,
String.Format("Expecting userflowCount : {0} to be the # of userflows : {1} .",
UserflowReporter.UserflowCount(),
loggedUserflows.Length));
foreach (Userflow userflow in loggedUserflows)
{
int index = Int32.Parse(userflow.Name());
Assert.IsTrue(((index >= 0) && (index < UserflowReporter.MAX_USERFLOW_COUNT)),
String.Format("Expecting userflow name to be an expected value between 0 and"
+ "MAX_USERFLOW_COUNT ({0}), name was {1}",
UserflowReporter.MAX_USERFLOW_COUNT,
index));
}
}
internal Userflow(string name, int value) : this()
{
this.name = StringUtils.TruncateString(name, MAX_NAME_LENGTH);
// timeout in milliseconds (Applying "userflow specific configuration"
// can only be done after we know "name" of this userflow.)
timeout = ClampTimeout(Int32.MaxValue);
if (value == NULL_VALUE)
{
value = DefaultValue();
}
this.value = value;
UserflowReporter.Save(this);
}
public void TestSaveLoad()
{
// Load saved userflow. Does it look the same?
// Extract fields from userflow before saving.
Userflow example1 = ExampleUserflow();
string firstName = example1.Name();
UserflowState firstState = example1.State();
long firstTimeout = example1.Timeout();
int firstValue = example1.Value();
long firstEyeTime = example1.EyeTime();
string firstBeginTime = example1.BeginTimeString();
string firstEndTime = example1.EndTimeString();
// Save followed by load.
UserflowReporter.Background();
UserflowReporter.Foreground();
example1 = Userflow.UserflowForName(firstName);
Assert.IsNotNull(example1,
"Expecting to find example1 again");
// Extract fields from loaded userflow.
string secondName = example1.Name();
UserflowState secondState = example1.State();
long secondTimeout = example1.Timeout();
int secondValue = example1.Value();
long secondEyeTime = example1.EyeTime();
string secondBeginTime = example1.BeginTimeString();
string secondEndTime = example1.EndTimeString();
// Everything is supposed to match now (within limits of persisting doubles).
Assert.IsTrue(firstState == secondState,
"Expecting firstState==secondState");
Assert.IsTrue(firstName == secondName,
"Expecting firstName==secondName");
Assert.IsTrue(firstTimeout == secondTimeout,
"Expecting firstTimeout==secondTimeout");
Assert.IsTrue(firstValue == secondValue,
"Expecting firstValue==secondValue");
Assert.IsTrue(firstEyeTime == secondEyeTime,
"Expecting firstEyeTime==secondEyeTime");
Assert.IsTrue(firstBeginTime == secondBeginTime,
"Expecting firstBeginTime==secondBeginTime");
Assert.IsTrue(firstEndTime == secondEndTime,
"Expecting firstEndTime==secondEndTime");
//UserflowReporter.Background();
Trace.WriteLine("testSaveLoad EXITING");
Trace.WriteLine("");
}
internal Userflow(string name, long beginTime, long endTime) : this(name, 0)
{
////////////////////////////////////////////////////////////////
// Input:
// name = userflow name
// beginTime = userflow begin time in ticks
// endTime = userflow end time in ticks
// NOTE: Automatic userflows ("App Load", "App Foreground", "App Background")
////////////////////////////////////////////////////////////////
state = UserflowState.ENDED;
SetBeginTime(beginTime);
SetEndTime(endTime);
eyeTime = endTime - beginTime;
SetForegroundTime(beginTime);
// This "Save" needs to occur after the "state" assigned above is known.
Debug.WriteLine("Reporting '" + name + "' == " + (eyeTime / (double)TimeUtils.TICKS_PER_SEC) + " seconds");
UserflowReporter.Save(this);
}
private void SetState(UserflowState newState, long nowTime)
{
// Establishes newState for userflow at nowTime .
state = newState;
isForegrounded = UserflowReporter.isForegrounded;
switch (state)
{
case UserflowState.CANCELLED:
SetEndTime(nowTime);
RemoveTimer();
break;
case UserflowState.BEGUN:
SetBeginTime(nowTime);
if (isForegrounded)
{
SetForegroundTime(nowTime);
CreateTimer();
}
break;
default:
// Final state
SetEndTime(nowTime);
RemoveTimer();
if (isForegrounded)
{
// Entering final state is effectively closing early ahead of
// the time when app may be backgrounded later. The persisted
// record gets the correct additional "eye time".
eyeTime += nowTime - foregroundTime;
isForegrounded = false;
}
if (newState == UserflowState.TIMEOUT)
{
Crittercism.OnUserflowTimeOut(new CRUserflowEventArgs(name));
}
break;
}
UserflowReporter.Save(this);
}
internal static Userflow UserflowForName(string name)
{
return(UserflowReporter.UserflowForName(name));
}
internal static Userflow[] AllUserflows()
{
return(UserflowReporter.AllUserflows());
}
private int DefaultValue()
{
int answer = UserflowReporter.DefaultValue(name);
return(answer);
}
private int ClampTimeout(int newTimeout)
{
int answer = UserflowReporter.ClampTimeout(name, newTimeout);
return(answer);
}
public void TestCleanup()
{
// Use TestCleanup to run code after each test has run
UserflowReporter.Shutdown();
}
public void TestInitialize()
{
// Use TestInitialize to run code before running each test
UserflowReporter.Init();
}
