/**
* Initialize permanently existing procfs files.
*/
static int init_permanent_files(void)
{
struct procfs_file ** file;
procfs_read_funcs = kcalloc(SET_COUNT(procfs_files),
sizeof(procfs_readfn_t *));
procfs_write_funcs = kcalloc(SET_COUNT(procfs_files),
sizeof(procfs_writefn_t *));
procfs_rele_funcs = kcalloc(SET_COUNT(procfs_files),
sizeof(procfs_relefn_t *));
if (!(procfs_read_funcs && procfs_write_funcs && procfs_rele_funcs))
return -ENOMEM;
SET_FOREACH(file, procfs_files) {
enum procfs_filetype filetype = (*file)->filetype;
procfs_read_funcs[filetype] = (*file)->readfn;
procfs_write_funcs[filetype] = (*file)->writefn;
procfs_rele_funcs[filetype] = (*file)->relefn;
if (filetype > PROCFS_KERNEL_SEPARATOR) {
const char * filename = (*file)->filename;
create_proc_file(vn_procfs, 0, filename, filetype);
}
}
return 0;
}
void
run_tests(void)
{
struct regression_test **testp;
printf("1..%td\n", SET_COUNT(regression_tests_set));
test_index = 1;
SET_FOREACH(testp, regression_tests_set) {
test_acknowleged = 0;
test = *testp;
test->rt_function();
if (!test_acknowleged)
print_status("not ok", "unknown status");
test_index++;
}
int unitTest()
{
// debugging diagnostics:
int dbgWinLose = 0, dbgNumTurnsNeStrlen = 0, dbgNumTurnsNeEndDepth = 0;
int dbgRobotWinsEven = 0, dbgHumanWinsOdd = 0;
int dbgRobotNotBranch = 0, dbgBranchNotRobot = 0;
int numCombos = 0;
for (char c = 'a'; c <= 'z'; c++) {
printf("\n%c 1 3 5 7 9 1 3 5 7 9 1\n", toupper(c));
const EvOdNode *ghostNode = getRoot()->getBranchAtLetter(c);
int j = 0, totalCount = 0, humanWins = 0, robotWins = 0;
WordLenT numTurns = 8888, tmpDepth = 0;
const char *aLastWord = NULL, *maxWord = NULL;
for (const EvOdNode *branch = ghostNode->getFirstChild(); branch != NULL; branch = branch->getNextSibling()) {
numCombos++;
SET_COUNT(0);
bool isRobotWinner = branch->evalIsWinnerGetEnds(numTurns, &aLastWord);
bool isRobotWinWin = branch->isWinnerMemo();
bool isRobotLoser = isLoserNode(branch);
if (isRobotWinner != isRobotWinWin || isRobotWinner == isRobotLoser) {
dbgWinLose++;
}
if ( isRobotWinner ) {
robotWins++;
} else {
humanWins++;
}
if (tmpDepth < numTurns) {
tmpDepth = numTurns;
maxWord = aLastWord;
}
totalCount += fsCounter;
//if (isRobotWinner)
printf("%2d %c %s: %2d == %2d turns: %c -> %-16s %-16s %5d\n"
, ++j
, (branch->getIsWinner() ? 'r' : 'H')
, (isRobotWinner ? "roBOT" : "HUMan")
, branch->getEndDepth()
, numTurns
, branch->getLetter()
, (aLastWord ? aLastWord : "----")
, branch->getEndWord()
, fsCounter
);
if ( isRobotWinner && (numTurns % 2) == 0) {
dbgRobotWinsEven++;
}
if (! isRobotWinner && (numTurns % 2) == 1) {
dbgHumanWinsOdd++;
}
int lastLen = aLastWord ? strlen(aLastWord) : 0;
if (numTurns != lastLen) {
dbgNumTurnsNeStrlen++;
}
if (isRobotWinner && ! branch->getIsWinner()) {
dbgRobotNotBranch++;
}
if ( ! isRobotWinner && branch->getIsWinner()) {
dbgBranchNotRobot++;
}
if (branch->getEndDepth() != numTurns) {
dbgNumTurnsNeEndDepth++;
}
}
printf("%s takes %c, max turns %d: %s\n", (robotWins > 0 ? "ROBOT (Player 2)" : "HUMAN (Player 1)")
, toupper(c), tmpDepth, maxWord);
}
if (dbgRobotNotBranch || dbgBranchNotRobot) {
printf("Bugs: RobotNotBranch: %d BranchNotRobot: %d\n", dbgRobotNotBranch, dbgBranchNotRobot);
}
if (dbgNumTurnsNeEndDepth) {
printf("Bugs: Of %d trials, TurnsNEmSteps: %d\n", numCombos, dbgNumTurnsNeEndDepth);
}
return 0;
}
/**
* Probe to see if an NVRAM data class in @p classes supports parsing
* of the data mapped by @p io, returning the parsed data in @p data.
*
* The caller is responsible for deallocating the returned instance via
* bhnd_nvram_data_release().
*
* @param[out] data On success, the parsed NVRAM data instance.
* @param io An I/O context mapping the NVRAM data to be copied and parsed.
* @param classes An array of NVRAM data classes to be probed, or NULL to
* probe the default supported set.
* @param num_classes The number of NVRAM data classes in @p classes.
*
* @retval 0 success
* @retval ENXIO if no class is found capable of parsing @p io.
* @retval non-zero if an error otherwise occurs during allocation,
* initialization, or parsing of the NVRAM data, a regular unix error code
* will be returned.
*/
int
bhnd_nvram_data_probe_classes(struct bhnd_nvram_data **data,
struct bhnd_nvram_io *io, bhnd_nvram_data_class *classes[],
size_t num_classes)
{
bhnd_nvram_data_class *cls;
int error, prio, result;
cls = NULL;
prio = 0;
*data = NULL;
/* If class array is NULL, default to our linker set */
if (classes == NULL) {
classes = SET_BEGIN(bhnd_nvram_data_class_set);
num_classes = SET_COUNT(bhnd_nvram_data_class_set);
}
/* Try to find the best data class capable of parsing io */
for (size_t i = 0; i < num_classes; i++) {
bhnd_nvram_data_class *next_cls;
next_cls = classes[i];
/* Try to probe */
result = bhnd_nvram_data_probe(next_cls, io);
/* The parser did not match if an error was returned */
if (result > 0)
continue;
/* Lower priority than previous match; keep
* searching */
if (cls != NULL && result <= prio)
continue;
/* Drop any previously parsed data */
if (*data != NULL) {
bhnd_nvram_data_release(*data);
*data = NULL;
}
/* If this is a 'maybe' match, attempt actual parsing to
* verify that this does in fact match */
if (result <= BHND_NVRAM_DATA_PROBE_MAYBE) {
/* If parsing fails, keep searching */
error = bhnd_nvram_data_new(next_cls, data, io);
if (error)
continue;
}
/* Record best new match */
prio = result;
cls = next_cls;
/* Terminate search immediately on
* BHND_NVRAM_DATA_PROBE_SPECIFIC */
if (result == BHND_NVRAM_DATA_PROBE_SPECIFIC)
break;
}
/* If no match, return error */
if (cls == NULL)
return (ENXIO);
/* If the NVRAM data was not parsed above, do so now */
if (*data == NULL) {
if ((error = bhnd_nvram_data_new(cls, data, io)))
return (error);
}
return (0);
}
