nsresult
AsyncNoShutdownTest(int testNumber)
{
// This test gets a service, and also gets an async request for shutdown,
// but the service doesn't get shut down because some other client (who's
// not participating in the async shutdown game as he should) is
// continuing to hang onto the service. This causes myServ variable to
// get set to NULL, but the service doesn't get unloaded right away as
// it should.
nsresult err;
err = BeginTest(testNumber);
if (err != NS_OK) return err;
// Create some other user of kIMyServiceCID, preventing it from
// really going away:
IMyService* otherClient;
err = CallGetService(kIMyServiceCID, &otherClient);
if (err != NS_OK) return err;
err = AsyncShutdown(testNumber);
if (err != NS_OK) return err;
err = EndTest(testNumber);
// Finally, release the other client.
NS_RELEASE(otherClient);
return err;
}
void CtestDlg::ReDrawPolygonWithCurrentData()
{
m_pointList.clear();
m_result.clear();
BeginTest(m_test);
FILE* f = fopen("test", "rb");
int count = 0;
fread(&count, sizeof(count), 1, f);
count = count >> 2;
int breakCount = count;
for (int i =0; i < count; ++i)
{
if (breakCount <= i)
{
break;
}
float x;
float z;
fread(&x, sizeof(x), 1, f);
fread(&z, sizeof(z), 1, f);
Point p = {(float)x, (float)z};
m_pointList.push_back(p);
AddPointForTest(m_test, p.x, p.z);
}
RedrawWindow();
return;
}
void CtestDlg::OnRButtonDown(UINT nFlags, CPoint point)
{
// TODO: 在此添加消息处理程序代码和/或调用默认值
Point p = {point.x, point.y};
m_pointList.clear();
m_result.clear();
BeginTest(m_test);
RedrawWindow();
CDialog::OnRButtonDown(nFlags, point);
}
nsresult
SimpleTest(int testNumber)
{
// This test just gets a service, uses it and releases it.
nsresult err;
err = BeginTest(testNumber);
if (err != NS_OK) return err;
err = EndTest(testNumber);
return err;
}
void XmlTestReporter::ReportSummary(int totalTestCount, int failedTestCount,
int failureCount, float secondsElapsed)
{
AddXmlElement(m_ostream, NULL);
BeginResults(m_ostream, totalTestCount, failedTestCount, failureCount, secondsElapsed);
DeferredTestResultList const& results = GetResults();
for (DeferredTestResultList::const_iterator i = results.begin(); i != results.end(); ++i)
{
BeginTest(m_ostream, *i);
if (i->failed)
AddFailure(m_ostream, *i);
EndTest(m_ostream, *i);
}
EndResults(m_ostream);
}
void LatencyTest::handleMessage(const Message& msg, LatencyTestMessageType latencyTestMessage)
{
// For debugging.
/* if (msg.Type == Message_LatencyTestSamples)
{
MessageLatencyTestSamples* pSamples = (MessageLatencyTestSamples*) &msg;
if (pSamples->Samples.GetSize() > 0)
{
// Just show the first one for now.
Color c = pSamples->Samples[0];
OVR_DEBUG_LOG(("%d %d %d", c.R, c.G, c.B));
}
return;
}
*/
if (latencyTestMessage == LatencyTest_Timer)
{
if (!Device)
{
reset();
return;
}
if (State == State_WaitingForSettlePreCalibrationColorBlack)
{
// Send calibrate message to device and wait a while.
Device->SetCalibrate(CALIBRATE_BLACK);
State = State_WaitingForSettlePostCalibrationColorBlack;
OVR_DEBUG_LOG(("State_WaitingForSettlePreCalibrationColorBlack -> State_WaitingForSettlePostCalibrationColorBlack."));
setTimer(TIME_TO_WAIT_FOR_SETTLE_POST_CALIBRATION);
}
else if (State == State_WaitingForSettlePostCalibrationColorBlack)
{
// Change color to white and wait a while.
RenderColor = CALIBRATE_WHITE;
State = State_WaitingForSettlePreCalibrationColorWhite;
OVR_DEBUG_LOG(("State_WaitingForSettlePostCalibrationColorBlack -> State_WaitingForSettlePreCalibrationColorWhite."));
setTimer(TIME_TO_WAIT_FOR_SETTLE_PRE_CALIBRATION);
}
else if (State == State_WaitingForSettlePreCalibrationColorWhite)
{
// Send calibrate message to device and wait a while.
Device->SetCalibrate(CALIBRATE_WHITE);
State = State_WaitingForSettlePostCalibrationColorWhite;
OVR_DEBUG_LOG(("State_WaitingForSettlePreCalibrationColorWhite -> State_WaitingForSettlePostCalibrationColorWhite."));
setTimer(TIME_TO_WAIT_FOR_SETTLE_POST_CALIBRATION);
}
else if (State == State_WaitingForSettlePostCalibrationColorWhite)
{
// Calibration is done. Switch to color 1 and wait for it to settle.
RenderColor = COLOR1;
State = State_WaitingForSettlePostMeasurement;
OVR_DEBUG_LOG(("State_WaitingForSettlePostCalibrationColorWhite -> State_WaitingForSettlePostMeasurement."));
UInt32 waitTime = TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT + getRandomComponent(TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT_RANDOMNESS);
setTimer(waitTime);
}
else if (State == State_WaitingForSettlePostMeasurement)
{
// Prepare for next measurement.
// Create a new result object.
MeasurementResult* pResult = new MeasurementResult();
Results.PushBack(pResult);
State = State_WaitingToTakeMeasurement;
OVR_DEBUG_LOG(("State_WaitingForSettlePostMeasurement -> State_WaitingToTakeMeasurement."));
}
else if (State == State_WaitingForTestStarted)
{
// We timed out waiting for 'TestStarted'. Abandon this measurement and setup for the next.
getActiveResult()->TimedOutWaitingForTestStarted = true;
State = State_WaitingForSettlePostMeasurement;
OVR_DEBUG_LOG(("** Timed out waiting for 'TestStarted'."));
OVR_DEBUG_LOG(("State_WaitingForTestStarted -> State_WaitingForSettlePostMeasurement."));
UInt32 waitTime = TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT + getRandomComponent(TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT_RANDOMNESS);
setTimer(waitTime);
}
else if (State == State_WaitingForColorDetected)
{
// We timed out waiting for 'ColorDetected'. Abandon this measurement and setup for the next.
getActiveResult()->TimedOutWaitingForColorDetected = true;
State = State_WaitingForSettlePostMeasurement;
OVR_DEBUG_LOG(("** Timed out waiting for 'ColorDetected'."));
OVR_DEBUG_LOG(("State_WaitingForColorDetected -> State_WaitingForSettlePostMeasurement."));
UInt32 waitTime = TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT + getRandomComponent(TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT_RANDOMNESS);
setTimer(waitTime);
}
}
else if (latencyTestMessage == LatencyTest_ProcessInputs)
{
if (State == State_WaitingToTakeMeasurement)
{
if (!Device)
{
reset();
return;
}
// Send 'StartTest' feature report with opposite target color.
if (RenderColor == COLOR1)
{
RenderColor = COLOR2;
}
else
{
RenderColor = COLOR1;
}
getActiveResult()->TargetColor = RenderColor;
// Record time so we can determine usb roundtrip time.
getActiveResult()->StartTestSeconds = Timer::GetSeconds();
Device->SetStartTest(RenderColor);
State = State_WaitingForTestStarted;
OVR_DEBUG_LOG(("State_WaitingToTakeMeasurement -> State_WaitingForTestStarted."));
setTimer(TIMEOUT_WAITING_FOR_TEST_STARTED);
LatencyTestDisplay ltd(2, 0x40090040);
Device->SetDisplay(ltd);
}
}
else if (msg.Type == Message_LatencyTestButton)
{
BeginTest();
}
else if (msg.Type == Message_LatencyTestStarted)
{
if (State == State_WaitingForTestStarted)
{
clearTimer();
// Record time so we can determine usb roundtrip time.
getActiveResult()->TestStartedSeconds = Timer::GetSeconds();
State = State_WaitingForColorDetected;
OVR_DEBUG_LOG(("State_WaitingForTestStarted -> State_WaitingForColorDetected."));
setTimer(TIMEOUT_WAITING_FOR_COLOR_DETECTED);
}
}
else if (msg.Type == Message_LatencyTestColorDetected)
{
if (State == State_WaitingForColorDetected)
{
// Record time to detect color.
MessageLatencyTestColorDetected* pDetected = (MessageLatencyTestColorDetected*) &msg;
UInt16 elapsedTime = pDetected->Elapsed;
OVR_DEBUG_LOG(("Time to 'ColorDetected' = %d", elapsedTime));
getActiveResult()->DeviceMeasuredElapsedMilliS = elapsedTime;
if (areResultsComplete())
{
// We're done.
processResults();
reset();
}
else
{
// Run another measurement.
State = State_WaitingForSettlePostMeasurement;
OVR_DEBUG_LOG(("State_WaitingForColorDetected -> State_WaitingForSettlePostMeasurement."));
UInt32 waitTime = TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT + getRandomComponent(TIME_TO_WAIT_FOR_SETTLE_POST_MEASUREMENT_RANDOMNESS);
setTimer(waitTime);
LatencyTestDisplay ltd(2, 0x40400040);
Device->SetDisplay(ltd);
}
}
}
else if (msg.Type == Message_DeviceRemoved)
{
reset();
}
}
