/*
getBool
Gets boolean value from key.
Throws an error if appropriate.
If an error occurs, value is set to false.
*/
void KeyValueReader::getBool(const std::string &key, bool &value) const
{
string valueString;
// Default value
value = false;
// Get value from key as string
getString(key, valueString);
// Check for true
if (areStringsEqual(valueString, "true")) {
value = true;
return;
}
// Check for false
if (areStringsEqual(valueString, "false")) {
value = false;
return;
}
// String conversion error if we get here
c_data->printMessage("Error converting value to bool");
throw ExceptionStringConversionError;
}
/*
* Runs a command recived from the defined input stream
*/
static bool RunCommand(char* command, Yad3Program program) {
if (command[0] == COMMENT_SIGN) return true;
int size;
char** params = NULL;
bool should_continue = true;
if (!splitString(command, &size, ¶ms)) {
writeToErrorOutStream(MTM_OUT_OF_MEMORY);
should_continue = false;
} else if (params == NULL) {
return true;
} else if (params[0][0] == '\n') {
should_continue = true;
} else if (areStringsEqual(params[0], USER_CUSTOMER)) {
should_continue = RunCustomerCommand(params, program);
} else if (areStringsEqual(params[0], USER_REALTOR)) {
should_continue = RunRealtorCommand(params, program);
} else if (areStringsEqual(params[0], USER_REPORTER)) {
should_continue = RunReporterCommand(params, program);
} else {
writeToErrorOutStream(MTM_INVALID_COMMAND_LINE_PARAMETERS);
should_continue = false;
}
matrixDestroy(params, size);
return should_continue;
}
/*
* GetInputFileAdress:
*
* method gets input/output address from program input parameters.
*
* @param input_parameters array of input parameters
* @param parameter_count size of parameters array
*
* @return
* false if parameters are not good; else returns true.
*/
static char* GetInputsPaths(char *input[], int count, bool find_input) {
if ((count >= 3) &&
(areStringsEqual(input[1], (find_input ? INPUT_SIGN : OUTPUT_SIGN)))) {
return input[2];
}
if ((count == 5) &&
(areStringsEqual(input[3], (find_input ? INPUT_SIGN : OUTPUT_SIGN)))) {
return input[4];
}
return NULL;
}
/*
* Runs one of the possible Customer command
*/
static bool RunCustomerCommand(char** params, Yad3Program program) {
if (areStringsEqual(params[1], ACTION_ADD_USER)) {
return RunAddCustumer(params, program);
} else if (areStringsEqual(params[1], ACTION_REMOVE_USER)) {
return RunRemoveCustumer(params, program);
} else if (areStringsEqual(params[1], ACTION_PURCHASE)) {
return RunCustumerPurchase(params, program);
} else if (areStringsEqual(params[1], ACTION_MAKE_OFFER)) {
return RunMakeOffer(params, program);
} else {
writeToErrorOutStream(MTM_INVALID_COMMAND_LINE_PARAMETERS);
return false;
}
}
/*
* Runs all the possible Reporter commands
*/
static bool RunReporterCommand(char** params, Yad3Program program) {
if (areStringsEqual(params[1], REPORT_RELEVENT_REALTORS)) {
RunPrintRealventRealtorReport(params, program);
return true;
} else if (areStringsEqual(params[1], REPORT_SIGNIFICANT_REALTORS)) {
RunSignificantRealtorReport(params, program);
return true;
}else if (areStringsEqual(params[1], REPORT_PAYING_CUSTOMERS)) {
RunPayingCustumersReport(params, program);
return true;
} else {
writeToErrorOutStream(MTM_INVALID_COMMAND_LINE_PARAMETERS);
return false;
}
}
/**
* Test copy method
*/
static bool testOfferCopy() {
char* client_address = "*****@*****.**";
char* agent_address = "*****@*****.**";
Email client, agent;
ASSERT_TEST(emailCreate(client_address, &client) == EMAIL_SUCCESS);
ASSERT_TEST(emailCreate(agent_address, &agent) == EMAIL_SUCCESS);
char* serivce_name = "my simple service";
Offer offer, copy;
ASSERT_TEST(offerCreate(client, agent, serivce_name, 12, 5000, &offer)
== OFFER_SUCCESS);
ASSERT_TEST(offer != NULL);
ASSERT_TEST(offerCopy(NULL, NULL) == OFFER_NULL_PARAMETERS);
ASSERT_TEST(offerCopy(offer, NULL) == OFFER_NULL_PARAMETERS);
ASSERT_TEST(offerCopy(NULL, ©) == OFFER_NULL_PARAMETERS);
ASSERT_TEST(offerCopy(offer, ©) == OFFER_SUCCESS);
ASSERT_TEST(copy != NULL);
ASSERT_TEST(emailAreEqual(offerGetAgentEmail(copy),agent) == true);
ASSERT_TEST(emailAreEqual(offerGetClientEmail(copy),client) == true);
ASSERT_TEST(areStringsEqual(offerGetServiceName(copy),serivce_name)
== true);
ASSERT_TEST(offerGetApartmentId(copy) == 12);
ASSERT_TEST(offerGetPrice(copy) == 5000);
offerDestroy(copy);
offerDestroy(offer);
emailDestroy(client);
emailDestroy(agent);
return true;
}
TestResult* convertStringToJsonStringTestTemplate(char* x, char* expected,
char* testName) {
char* actual = convertStringToJsonString(x);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertStringToJsonStringTestEmptyString";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* convertIntToJsonFieldBoolTestTemplate(int x, char* fieldName,
char* expected, char* testName) {
char* actual = convertIntToJsonFieldBool(fieldName, x);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = testName;
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* allocateNewStringTestTemplate(char* x, int xLength, char* expected,
char* testName) {
char* actual = allocateNewString(x, xLength);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = testName;
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* stringConcat3TestTemplate(char* string1, char* string2,
char* string3, char* expected, char* testName) {
char* actual = stringConcat3(string1, string2, string3);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = testName;
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
eMeasureType convertStringToMeasureType(LPCWSTR i_String)
{
eMeasureType result;
if (areStringsEqual(i_String, L"Temperature"))
{
result = MeasureTemperature;
}
else if (areStringsEqual(i_String, L"MaxTemperature"))
{
result = MeasureMaxTemperature;
}
else if (areStringsEqual(i_String, L"TjMax"))
{
result = MeasureTjMax;
}
else if (areStringsEqual(i_String, L"Load"))
{
result = MeasureLoad;
}
else if (areStringsEqual(i_String, L"Vid"))
{
result = MeasureVid;
}
else if (areStringsEqual(i_String, L"CpuSpeed"))
{
result = MeasureCpuSpeed;
}
else if (areStringsEqual(i_String, L"BusSpeed"))
{
result = MeasureBusSpeed;
}
else if (areStringsEqual(i_String, L"BusMultiplier"))
{
result = MeasureBusMultiplier;
}
else if (areStringsEqual(i_String, L"CpuName"))
{
result = MeasureCpuName;
}
else
{
result = MeasureTemperature;
RmLog(LOG_WARNING, L"CoreTemp.dll: Invalid CoreTempType");
}
return result;
}
TestResult* convertIntToStringTest() {
int x = -10;
char* expected = "-10";
char* actual = convertIntToString(x);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertIntToStringTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* convertStringToJsonFieldNameTest() {
char* x = "name";
char* expected = "\"name\"";
char* actual = convertStringToJsonFieldName(x);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertStringToJsonFieldNameTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* createNullJsonFieldTest() {
char* expected = "\"field\":null";
char* fieldName = "field";
char* actual = createNullJsonField(fieldName);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "createNullJsonFieldTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
/*
findKey
Returns the index of the key in the keyVector.
If key is not found, returns KEY_NOT_FOUND.
*/
static
int findKey(const vector<string> &keyVector, const string &key)
{
for (size_t i = 0; i < keyVector.size(); i++) {
if (areStringsEqual(key, keyVector[i])) {
return i;
}
}
return KEY_NOT_FOUND;
}
TestResult* convertDoubleToStringTest() {
double x = -123.123;
double fractionalPartLength = 2;
char* expected = "-123.12";
char* actual = convertDoubleToString(x, fractionalPartLength);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertDoubleToStringTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* convertIntToJsonFieldTest() {
int x = -1;
char* fieldName = "number";
char* expected = "\"number\":-1";
char* actual = convertIntToJsonField(fieldName, x);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertIntToJsonFieldTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* convertStringToJsonFieldTest() {
char* x = "value";
char* fieldName = "string";
char* expected = "\"string\":\"value\"";
char* actual = convertStringToJsonField(fieldName, x);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertStringToJsonFieldTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
TestResult* convertDoubleToJsonFieldTest() {
double x = -123.123;
int fractionalPartLength = 2;
char* fieldName = "double";
char* expected = "\"double\":-123.12";
char* actual = convertDoubleToJsonField(fieldName, x,
fractionalPartLength);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "convertDoubleToJsonFieldTest";
r -> passed = areStringsEqual(actual, expected);
free(actual);
return r;
}
/*
* checkProgramParameters:
*
* method checks if the program input parameters are correct.
*
* correct parameters are:
* - only one parameter
* - three parameters, the third must be INPUT_SIGN or OUTPUT_SIGN
* - five parameters, the third and the fifth must be INPUT_SIGN and
* OUTPUT_SIGN (one must be OUTPUT_SIGN and the second must be INPUT_SIGN)
*
* @param input_parameters array of input parameters
* @param parameter_count size of parameters array
*
* @return
* false if parameters are not good; else returns true.
*/
static bool checkProgramParameters(char *input[], int count) {
if (count == 1) return true;
if ((count == 3) &&
((areStringsEqual(input[1], INPUT_SIGN)) ||
(areStringsEqual(input[1], OUTPUT_SIGN)))) return true;
if ((count == 5) &&
(((areStringsEqual(input[1], INPUT_SIGN)) &&
(areStringsEqual(input[3], OUTPUT_SIGN))) ||
((areStringsEqual(input[1], OUTPUT_SIGN)) &&
(areStringsEqual(input[3], INPUT_SIGN))))) return true;
return false;
}
/*
* Runs all the realtor commands
*/
static bool RunRealtorCommand(char** params, Yad3Program program) {
if (areStringsEqual(params[1], ACTION_ADD_USER)) {
return RunAddRealtor(params, program);
} else if (areStringsEqual(params[1], ACTION_REMOVE_USER)) {
return RunRemoveRealtor(params, program);
} else if (areStringsEqual(params[1], ACTION_ADD_SERVICE)) {
return RunRealtorAddApartmentService(params, program);
} else if (areStringsEqual(params[1], ACTION_REMOVE_SERVICE)) {
return RunRealtorRemoveApartmentService(params, program);
} else if (areStringsEqual(params[1], ACTION_ADD_APARTMENT)) {
return RunRealtorAddApartmentToRealtor(params, program);
} else if (areStringsEqual(params[1], ACTION_REMOVE_APARTMENT)) {
return RunRemoveApartmentFromRealtor(params, program);
} else if (areStringsEqual(params[1], ACTION_RESPOND_OFFER)) {
return RunResponeToOffer(params, program);
} else {
writeToErrorOutStream(MTM_INVALID_COMMAND_LINE_PARAMETERS);
return false;
}
}
static RestoreSaveResult restoreSaveStateFromFile(CPU *cpu, MMU *mmu, const char *romName, int saveSlot) {
CO_ASSERT(saveSlot >= 0 && saveSlot <= 9);
char *tmpROMNamePtr = mmu->romName;
CartRAMPlatformState tmpCartRAMPlatformState = mmu->cartRAMPlatformState;
u8 *tmpROM = mmu->romData;
char tmpROMName[MAX_ROM_NAME_LEN + 1] = {};
CPU backupCPU = *cpu;
MMU backupMMU = *mmu;
char *saveStateFileName = nullptr;
buf_gen_memory_printf(saveStateFileName, "%s_%d.gbes", romName, saveSlot);
FILE *f = fopen(saveStateFileName, "rb");
if (!f) {
return RestoreSaveResult::NothingInSlot;
}
buf_gen_memory_free(saveStateFileName);
SerializingState ss;
ss.f = f;
ss.isWriting = false;
auto res = serialize(&ss.version, &ss);
if (res != FileSystemResultCode::OK) {
CO_ERR("Could not read version number of save state");
return RestoreSaveResult::Error;
}
res = serialize(tmpROMName, mmu->romNameLen, &ss);
if (res != FileSystemResultCode::OK) {
CO_ERR("Could not restore game state save. Could not read rom name.");
fclose(f);
return RestoreSaveResult::Error;
}
if (!areStringsEqual(romName, tmpROMName, mmu->romNameLen)) {
CO_ERR("Save state is not for this rom! Actual %s, Expected %s", tmpROMName, romName);
fclose(f);
return RestoreSaveResult::Error;
}
res = serialize(cpu, &ss);
if (res != FileSystemResultCode::OK) {
CO_ERR("Could not load game state. Could not load CPU.");
goto error;
}
res = serialize(mmu, &ss);
if (res != FileSystemResultCode::OK) {
CO_ERR("Could not load game state. Could not load MMU.");
goto error;
}
if (mmu->hasRAM && mmu->hasBattery) {
mmu->cartRAMPlatformState = tmpCartRAMPlatformState;
usize expectedRAMLen = (usize)mmu->cartRAMSize;
if (mmu->hasRTC) expectedRAMLen += sizeof(RTCFileState);
if (expectedRAMLen != mmu->cartRAMPlatformState.ramLen) {
goto error;
}
copyMemory(mmu->cartRAM, mmu->cartRAMPlatformState.cartRAMFileMap, mmu->cartRAMSize);
}
mmu->romName = tmpROMNamePtr;
mmu->romData = tmpROM;
fclose(f);
return RestoreSaveResult::Success;
error:
*cpu = backupCPU;
*mmu = backupMMU;
fclose(f);
return RestoreSaveResult::Error;
}
