MStatus exampleCameraSetViewCmd::doEditFlags() // // Description: // Handle edits for flags added by this class. // If the flag is unknown, return MS::kSuccess and the parent class // will attempt to process the flag. Returning MS::kUnknownParameter // will cause the parent class to process the flag. // { MPx3dModelView *user3dModelView = modelView(); if (NULL == user3dModelView) { MGlobal::displayError("NULL == user3dModelView!"); return MS::kFailure; } // This is now safe to do, since the above test passed. // exampleCameraSetView *dView = (exampleCameraSetView *)user3dModelView; MArgParser argData = parser(); if (argData.isFlagSet(kTestMultiPackInitFlag)) { return initTests(*dView); } else if (argData.isFlagSet(kTestMultiPackResultsFlag)) { return testResults(*dView); } else if (argData.isFlagSet(kTestMultiPackClearFlag)) { return clearResults(*dView); } return MS::kUnknownParameter; }
static int test_blink(TestState *state) { TestState state2; int phase = 0; int count = 4; initState(&state2, " Subtest", state); while (--count >= 0) { if (startTest(&state2, "SET:pin-gpio13")) { if (serialRequest(&state2, "SET:pin-gpio13,%d", phase)) checkSerialResponse(&state2, "=S,0"); } if (startTest(&state2, "SET:pin-gpio15")) { if (serialRequest(&state2, "SET:pin-gpio15,%d", !phase)) checkSerialResponse(&state2, "=S,0"); } phase = !phase; msleep(500); } if (startTest(&state2, "SET:pin-gpio13")) { if (serialRequest(&state2, "SET:pin-gpio13,0")) checkSerialResponse(&state2, "=S,0"); } if (startTest(&state2, "SET:pin-gpio15")) { if (serialRequest(&state2, "SET:pin-gpio15,0")) checkSerialResponse(&state2, "=S,0"); } testResults(&state2); return state2.testPassed; }
TestResults ModelTester::Test(const std::string slideDir, const std::string outputDir) { std::vector<std::string> slideNames; std::vector<Slide> slides; SlideLoader::loadSlides(slideDir, slides, slideNames); cv::Mat totalPredictions; cv::Mat totalGroundTruth; for (int i = 0; i < slides.size(); ++i) { Slide slide = slides[i]; cv::Mat predictions = Test(slide, outputDir + "/" + slideNames[i] + "_predictions.yaml"); cv::Mat groundTruth = slide.getGroundTruth(); std::string groundTruthLoc = outputDir + "/" + slideNames[i] + "_groundTruth.bmp"; cv::imwrite(groundTruthLoc, renderHeatMap(slide.getTissueTiles(), groundTruth)); std::string heatMapLoc = outputDir + "/" + slideNames[i] + "_heatMap.bmp"; cv::imwrite(heatMapLoc, renderHeatMap(slide.getTissueTiles(), predictions)); totalPredictions.push_back(predictions); totalGroundTruth.push_back(groundTruth); } TestResults testResults(totalPredictions, totalGroundTruth); cv::imwrite(outputDir + "/ROC.bmp", testResults.plotROC(1000)); return testResults; }
int flcrd_quiz(Account & acct) { cout << "Beginning Flashcard Quiz." << endl; chr::system_clock::time_point timeStart; boost::chrono::duration<float> timeDiff; bool isWrong = true, disableHintMsg = false; vector<Flashcard> cards; string response, prompt; SmartPicker * picker; Hint myhint(" ", acct.getVerbose()); /* Choose flashcard set, then input */ cards[0].input(cards,listDicts()); { int index = 1; cout << "Pick how you're quizzed:\n" << " 1. LeastPicked\n" << " 2. Adaptive\n" << " 3. LeastCorrect\n" << " 4. Walk Through\n" << endl; index = ltest::readint<usInt>(">> "); switch (index) { case 1: cout << "You picked LeastPicked" << endl; picker = new LeastPicked; break; case 2: cout << "You picked Adaptive" << endl; picker = new Adaptive(cards.size()); break; case 3: cout << "You picked LeastCorrect" << endl; picker = new LeastCorrect; break; case 4: cout << "You picked WalkThrough" << endl; picker = new WalkThrough; break; default: cout << "Your choice isn't valid, so you're getting LeastPicked" << endl; picker = new LeastPicked; break; } } do { picker->getNextIndex(cards); // could we conditionally set this instead? myhint.setKey(cards[picker->getCurrentIndex()].getWord('B',ltest::randIndex(cards[picker->getCurrentIndex()].size('B')))); string sideAword = cards[picker->getCurrentIndex()].getWord('A',ltest::randIndex(cards[picker->getCurrentIndex()].size('A'))); usInt numOfTries = 0; prompt = sideAword; while (isWrong) { numOfTries++; timeStart = chr::system_clock::now(); response = ltest::readstring(prompt + ": "); timeDiff = chr::system_clock::now() - timeStart; /* options processing */ if ( response[0] == '-' ) /* if hint */ { if ( response[1] == 's' ) break; /* skip word */ else /* deal with response */ cout << myhint.handle(response, disableHintMsg); } else if ( response == "exit" ) { exitToMain = true; break; } else /* no hint, check response */ { /* TODO: if noun, and beginning with el or la (or los or las), and user * gets the article correct, do not require them to keep typing that... */ isWrong = ltest::isInvalidAnswer(response,cards[picker->getCurrentIndex()].getSideB()); if (isWrong) { if (acct.getVerbose()) { cout << "You are " \ << wordCompare::lcsPercent(cards[picker->getCurrentIndex()].getWord('B',0),response) \ << "%% correct.\n" \ << wordCompare::correctness(response,cards[picker->getCurrentIndex()].getWord('B',0)) << endl; } if ( (numOfTries % 5) == 0 && !disableHintMsg) { cout << myhint.help(sideAword.size()) << '\n'; prompt = sideAword; } else prompt = ltest::printWhitespace(sideAword.size()-1); } else if (acct.getVerbose()) cout << "Right!" << endl; } } /* finish this card */ cards[picker->getCurrentIndex()].recordPerformance(numOfTries,isWrong,timeDiff.count()); isWrong = true; // cout << response << " has " << ltest::isAccented(response) << " accents" << endl; } while (!exitToMain); testResults(cards,acct.getVerbose()); delete picker; return 0; }
static int test_001(TestState *state) { TestState state2; int listener1, listener2, connection1, count, result; char response[1024]; initState(&state2, " Subtest", state); if (startTest(&state2, "LISTEN")) { if (serialRequest(&state2, "LISTEN:HTTP,/robot*")) checkSerialResponse(&state2, "=S,^i", &listener1); } beginGroup(&state2); if (startTest(&state2, "PATH of a listener")) { if (!skipTest(&state2) && serialRequest(&state2, "PATH:%d", listener1)) checkSerialResponse(&state2, "=S,/robot*"); } if (startTest(&state2, "Send request to WX module")) { if (!skipTest(&state2)) { if (sendRequest(&state->moduleAddr, "POST", "/robot?gto=f", "") >= 0) passTest(&state2, ""); else failTest(&state2, ""); } } beginGroup(&state2); if (startTest(&state2, "POLL for incoming POST request")) { if (!skipTest(&state2)) { do { if (!serialRequest(&state2, "POLL")) break; } while (!waitAndCheckSerialResponse(&state2, "=N,0,0", "=P,^i,^i", &connection1, &listener2)); } } beginGroup(&state2); if (startTest(&state2, "listener handle returned by POLL")) { if (listener1 == listener2) passTest(&state2, ""); else failTest(&state2, ": got %d", listener2); } if (startTest(&state2, "PATH of a connection")) { if (!skipTest(&state2) && serialRequest(&state2, "PATH:%d", connection1)) checkSerialResponse(&state2, "=S,/robot"); } if (startTest(&state2, "ARG")) { if (!skipTest(&state2) && serialRequest(&state2, "ARG:%d,gto", connection1)) checkSerialResponse(&state2, "=S,f"); } if (startTest(&state2, "REPLY")) { if (!skipTest(&state2) && serialRequest(&state2, "REPLY:%d,200", connection1)) checkSerialResponse(&state2, "=S,^i", &count); } if (startTest(&state2, "POLL for send complete")) { if (!skipTest(&state2)) { do { if (!serialRequest(&state2, "POLL")) break; } while (!waitAndCheckSerialResponse(&state2, "=N,0,0", "=S,^i,0", &count, &listener2)); } } if (startTest(&state2, "Receive response from WX")) { if (!skipTest(&state2)) { if (receiveResponse((uint8_t *)response, sizeof(response), &result) >= 0) passTest(&state2, ""); else failTest(&state2, ""); } } if (startTest(&state2, "CLOSE")) { if (!skipTest(&state2) && serialRequest(&state2, "CLOSE:%d", listener1)) checkSerialResponse(&state2, "=S,0"); } testResults(&state2); return state2.testPassed; }
void run_tests(TestState *parent, int selectedTest) { TestState state; initState(&state, "Test", parent); state.selectedTest = selectedTest; if (startTest(&state, "the empty command")) { if (serialRequest(&state, "")) checkSerialResponse(&state, "=S,0"); } if (startTest(&state, "an invalid command")) { if (serialRequest(&state, "FOO")) checkSerialResponse(&state, "=E,1"); } #ifdef DO_BLINK_TEST if (startTest(&state, "Blink LEDs on GPIO13 and GPIO15")) { if (test_blink(&state)) passTest(&state, ""); else failTest(&state, ""); } #endif if (state.ssid) { if (startTest(&state, "switch to STA+AP mode")) { if (serialRequest(&state, "SET:wifi-mode,3")) checkSerialResponse(&state, "=S,0"); } if (startTest(&state, "JOIN")) { if (serialRequest(&state, "JOIN:%s,%s", state.ssid, state.passwd)) checkSerialResponse(&state, "=S,0"); if (state.testPassed) msleep(10000); // wait for WX to disconnect. It has a .5 second delay } beginGroup(&state); if (startTest(&state, "CHECK:station-ipaddr")) { if (!skipTest(&state)) { char ipaddr[32]; do { if (!serialRequest(&state, "CHECK:station-ipaddr")) break; } while (!waitAndCheckSerialResponse(&state, "=S,0.0.0.0", "=S,^s", ipaddr, sizeof(ipaddr))); if (state.testPassed) { infoTest(&state, "got '%s'", ipaddr); if (GetInternetAddress(ipaddr, 80, &state.moduleAddr) != 0) infoTest(&state, "error: failed to parse IP address '%s'", ipaddr); } } } } if (startTest(&state, "simple transaction")) { if (test_001(&state)) passTest(&state, ""); else failTest(&state, ""); } testResults(&state); }
ModelGenerationSeriesResult testSeries(std::string p_ontPath, std::vector<std::string>* p_requiredModelElements, int p_count, bool warmUp, bool global, bool verbose, int maxHopCount = 3, int maxStepCount = 10, std::function<void(supplementary::ClingWrapper *asp)> lambda = nullptr, int models = 1) { ModelGenerationSeriesResult result; result.numberTotal = p_count; result.numberSuccessful = 0; std::vector<ModelGenerationResult> testResults(p_count + 1); std::chrono::time_point<std::chrono::system_clock> start, end; result.totalTimeVar = 0; result.ontologyReadTimeVar = 0; result.ontologyReasonerTimeVar = 0; result.ontologyToASPTimeVar = 0; result.aspGroundingTimeVar = 0; result.aspSolvingTimeVar = 0; VarianceOnline totalTimeVar, ontologyReadTimeVar, ontologyReasonerTimeVar, ontologyToASPTimeVar, aspGroundingTimeVar, aspSolvingTimeVar, aspSatTimeVar, aspUnsatTimeVar, aspModelCountVar, aspAtomCountVar, aspBodiesCountVar, aspAuxAtomCountVar; if (warmUp) { ice::OntologyInterface::callJniGc(); std::cout << "Starting warm up " << std::flush; for (int i = 1; i < 101; ++i) { std::string ontology; if (this->testRepresentations) { ontology = p_ontPath + "0.owl"; } else { ontology = p_ontPath; } this->test(ontology, p_requiredModelElements, true, global, false, maxHopCount, maxStepCount); if (i % 10 == 0) { std::cout << "."; std::cout << std::flush; } } std::cout << " done." << std::endl; } for (int m = 0; m < models; ++m) { for (int i = 0; i < p_count; ++i) { std::cout << "Starting run " << (i + 1) << " ... "; start = std::chrono::system_clock::now(); std::string ontology; if (this->testRepresentations) { ontology = p_ontPath + std::to_string(m) + ".owl"; } else { ontology = p_ontPath; } auto r = this->test(ontology, p_requiredModelElements, false, global, verbose, maxHopCount, maxStepCount, lambda); if (r.successful) ++result.numberSuccessful; testResults.push_back(r); totalTimeVar.add(r.totalTime); ontologyReadTimeVar.add(r.ontologyReadTime); ontologyReasonerTimeVar.add(r.ontologyReasonerTime); ontologyToASPTimeVar.add(r.ontologyToASPTime); aspGroundingTimeVar.add(r.aspGroundingTime); aspSolvingTimeVar.add(r.aspSolvingTime); aspSatTimeVar.add(r.aspSatTime); aspUnsatTimeVar.add(r.aspUnsatTime); aspModelCountVar.add(r.aspModelCount); aspAtomCountVar.add(r.aspAtomCount); aspBodiesCountVar.add(r.aspBodiesCount); aspAuxAtomCountVar.add(r.aspAuxAtomCount); if (i == 0 && m == 0) { result.best = r; result.worst = r; result.avg = r; } else { result.avg.totalTime += r.totalTime; result.avg.ontologyReadTime += r.ontologyReadTime; result.avg.ontologyReasonerTime += r.ontologyReasonerTime; result.avg.ontologyToASPTime += r.ontologyToASPTime; result.avg.aspGroundingTime += r.aspGroundingTime; result.avg.aspSolvingTime += r.aspSolvingTime; result.avg.aspSatTime += r.aspSatTime; result.avg.aspUnsatTime += r.aspUnsatTime; result.avg.aspModelCount += r.aspModelCount; result.avg.aspAtomCount += r.aspAtomCount; result.avg.aspBodiesCount += r.aspBodiesCount; result.avg.aspAuxAtomCount += r.aspAuxAtomCount; if (r.totalTime < result.best.totalTime) result.best.totalTime = r.totalTime; else if (r.totalTime > result.worst.totalTime) result.worst.totalTime = r.totalTime; if (r.ontologyReadTime < result.best.ontologyReadTime) result.best.ontologyReadTime = r.ontologyReadTime; else if (r.ontologyReadTime > result.worst.ontologyReadTime) result.worst.ontologyReadTime = r.ontologyReadTime; if (r.ontologyReasonerTime < result.best.ontologyReasonerTime) result.best.ontologyReasonerTime = r.ontologyReasonerTime; else if (r.ontologyReasonerTime > result.worst.ontologyReasonerTime) result.worst.ontologyReasonerTime = r.ontologyReasonerTime; if (r.ontologyToASPTime < result.best.ontologyToASPTime) result.best.ontologyToASPTime = r.ontologyToASPTime; else if (r.ontologyToASPTime > result.worst.ontologyToASPTime) result.worst.ontologyToASPTime = r.ontologyToASPTime; if (r.aspGroundingTime < result.best.aspGroundingTime) result.best.aspGroundingTime = r.aspGroundingTime; else if (r.aspGroundingTime > result.worst.aspGroundingTime) result.worst.aspGroundingTime = r.aspGroundingTime; if (r.aspSolvingTime < result.best.aspSolvingTime) result.best.aspSolvingTime = r.aspSolvingTime; else if (r.aspSolvingTime > result.worst.aspSolvingTime) result.worst.aspSolvingTime = r.aspSolvingTime; if (r.aspSatTime < result.best.aspSatTime) result.best.aspSatTime = r.aspSatTime; else if (r.aspSatTime > result.worst.aspSatTime) result.worst.aspSatTime = r.aspSatTime; if (r.aspUnsatTime < result.best.aspUnsatTime) result.best.aspUnsatTime = r.aspUnsatTime; else if (r.aspUnsatTime > result.worst.aspUnsatTime) result.worst.aspUnsatTime = r.aspUnsatTime; if (r.aspModelCount < result.best.aspModelCount) result.best.aspModelCount = r.aspModelCount; else if (r.aspModelCount > result.worst.aspModelCount) result.worst.aspModelCount = r.aspModelCount; if (r.aspAtomCount < result.best.aspAtomCount) result.best.aspAtomCount = r.aspAtomCount; else if (r.aspAtomCount > result.worst.aspAtomCount) result.worst.aspAtomCount = r.aspAtomCount; if (r.aspBodiesCount < result.best.aspBodiesCount) result.best.aspBodiesCount = r.aspBodiesCount; else if (r.aspBodiesCount > result.worst.aspBodiesCount) result.worst.aspBodiesCount = r.aspBodiesCount; if (r.aspAuxAtomCount < result.best.aspAuxAtomCount) result.best.aspAuxAtomCount = r.aspAuxAtomCount; else if (r.aspAuxAtomCount > result.worst.aspAuxAtomCount) result.worst.aspAuxAtomCount = r.aspAuxAtomCount; } end = std::chrono::system_clock::now(); std::cout << "finished " << (r.successful ? "successful" : "unsuccessful") << " after: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << " ms, processing time: " << r.totalTime << " ms" << std::endl; } } result.totalTimeVar = totalTimeVar.getVariance(); result.ontologyReadTimeVar = ontologyReadTimeVar.getVariance(); result.ontologyReasonerTimeVar = ontologyReasonerTimeVar.getVariance(); result.ontologyToASPTimeVar = ontologyToASPTimeVar.getVariance(); result.aspGroundingTimeVar = aspGroundingTimeVar.getVariance(); result.aspSolvingTimeVar = aspSolvingTimeVar.getVariance(); result.aspSatTimeVar = aspSatTimeVar.getVariance(); result.aspUnsatTimeVar = aspUnsatTimeVar.getVariance(); result.aspModelCountVar = aspModelCountVar.getVariance(); result.aspAtomCountVar = aspAtomCountVar.getVariance(); result.aspBodiesCountVar = aspBodiesCountVar.getVariance(); result.aspAuxAtomCountVar = aspAuxAtomCountVar.getVariance(); int runCount = models * p_count; result.avg.totalTime /= runCount; result.avg.ontologyReadTime /= runCount; result.avg.ontologyReasonerTime /= runCount; result.avg.ontologyToASPTime /= runCount; result.avg.aspGroundingTime /= runCount; result.avg.aspSolvingTime /= runCount; result.avg.aspSatTime /= runCount; result.avg.aspUnsatTime /= runCount; result.avg.aspModelCount /= runCount; result.avg.aspAtomCount /= runCount; result.avg.aspBodiesCount /= runCount; result.avg.aspAuxAtomCount /= runCount; return result; }