Ticket #9160: modified_scummvm.patch

test/common/tokenizer.h

@@ +1 @@
+#include <cxxtest/TestSuite.h>
+#include "common/util.h"
+#include "common/tokenizer.h"
+
+class TokenizerTestSuite : public CxxTest::TestSuite {
+public:
+        void test_nextToken() {
+                
+                // test Common::StringTokenizer class
+
+                // test normal behavior
+                Common::StringTokenizer strTokenizer("Now, this is a test!", " ,!");
+                Common::String tokenArray[] = {"Now", "this", "is", "a", "test"};
+
+                for (int i = 0; i < ARRAYSIZE(tokenArray); i++ ) {
+                        // make sure nextToken works correctly
+                        TS_ASSERT_EQUALS(tokenArray[i], strTokenizer.nextToken());
+                }
+
+                // test edgy conditions:
+        
+                // Empty String
+                Common::StringTokenizer s1("");
+                TS_ASSERT_EQUALS("", s1.nextToken());
+                
+                // Empty Delimiter
+                Common::StringTokenizer s2("test String", "");
+                TS_ASSERT_EQUALS("test String", s2.nextToken());
+                
+                // String is the delimiter
+                Common::StringTokenizer s3("abc", "abc");
+                TS_ASSERT_EQUALS("", s3.nextToken());
+                // Tokenizer should be empty
+                TS_ASSERT(s3.empty());
+                
+                // consecutive delimiters in the string
+                Common::StringTokenizer s4("strstr,after all!!", "str, !");
+                TS_ASSERT_EQUALS("af", s4.nextToken());
+        }
+
+        void test_resetAndEmpty() {     
+                Common::StringTokenizer strTokenizer("Just, another test!", " ,!");
+
+                // test reset()
+                Common::String token1 = strTokenizer.nextToken(); //Just
+                strTokenizer.reset();
+                Common::String token2 = strTokenizer.nextToken(); //Just
+
+                TS_ASSERT_EQUALS(token1,token2);
+
+                // test empty()
+                TS_ASSERT(!strTokenizer.empty()); 
+                strTokenizer.nextToken(); //another
+                strTokenizer.nextToken(); //test
+                TS_ASSERT(strTokenizer.empty()); 
+        }
+
+};
+

common/error.h

@@ -66 +66 @@
         kUnknownError                           ///< Catch-all error, used if no other error code matches
 };
 
+/**
+ * Maps an error code to equivalent string description.
+ *
+ * @param error error code to be converted
+ * @return a pointer to string description of the error
+ */
+const char *errorToString(Error error);
+
+/**
+ * Displays an error dialog for some error code.
+ *
+ * @param error error code
+ * @param extraText extra text to be displayed in addition to default string description(optional)
+ */
+void displayErrorDialog(Error error, const char *extraText = "");
+
+/**
+ * Displays an error dialog for a given message.
+ *
+ * @param text message to be displayed
+ */
+void displayErrorDialog(const char *text);
+
 } // End of namespace Common
 
 #endif //COMMON_ERROR_H

common/error.cpp

@@ +1 @@
+#include "common/error.h"
+#include "common/util.h"
+#include "gui/message.h"
+
+namespace Common {
+
+/**
+ * Error Table: Maps error codes to their default descriptions 
+ */
+
+struct ErrorMessage {
+        Error error;
+        const char *errMsg;
+};
+
+static const ErrorMessage _errMsgTable[] = {
+        { kInvalidPathError, "Invalid Path" },
+        { kNoGameDataFoundError, "Game Data not found" },
+        { kUnsupportedGameidError, "Game Id not supported" },
+        { kUnsupportedColorMode, "Unsupported Color Mode" },
+
+        { kReadPermissionDenied, "Read permission denied" },
+        { kWritePermissionDenied, "Write permission denied" },  
+
+        // The following three overlap a bit with kInvalidPathError and each other. Which to keep?
+        { kPathDoesNotExist, "Path not exists" },
+        { kPathNotDirectory, "Path not a directory" },
+        { kPathNotFile, "Path not a file" },
+
+        { kCreatingFileFailed, "Can not create file" },
+        { kReadingFailed, "Reading failed" },                           
+        { kWritingFailed, "Writing data failed" },              
+
+        { kUnknownError, "Unknown Error" }
+};
+
+const char *errorToString(Error error) {
+
+        for (int i = 0; i < ARRAYSIZE(_errMsgTable); i++) {
+                if (error == _errMsgTable[i].error) {
+                        return _errMsgTable[i].errMsg;
+                }
+        }
+
+        return "Unknown Error";
+}
+
+void displayErrorDialog(const char *text) {     
+        GUI::MessageDialog alert(text);
+        alert.runModal();
+}
+
+void displayErrorDialog(Error error, const char *extraText) {
+        String errorText(extraText);
+        errorText += " ";
+        errorText += errorToString(error);
+        GUI::MessageDialog alert(errorText);
+        alert.runModal();
+}
+
+}

common/module.mk

@@ -24 +24 @@
         unzip.o \
         util.o \
         xmlparser.o \
-        zlib.o
+        zlib.o \
+        error.o
 
 # Include common rules
 include $(srcdir)/rules.mk

base/main.cpp

@@ -136 +136 @@
         if (!engine || err != Common::kNoError) {
                 // TODO: Show an error dialog or so?
                 // TODO: Also take 'err' into consideration...
+                
+                // An errorDialog for this and engine related errors is displayed already in the scummvm_main function
+                // Is a separate dialog here still required?
+                
                 //GUI::MessageDialog alert("ScummVM could not find any game in the specified directory!");
                 //alert.runModal();
-                const char *errMsg = 0;
-                switch (err) {
-                case Common::kInvalidPathError:
-                        errMsg = "Invalid game path";
-                        break;
-                case Common::kNoGameDataFoundError:
-                        errMsg = "Unable to locate game data";
-                        break;
-                default:
-                        errMsg = "Unknown error";
-                }
+                const char *errMsg = Common::errorToString(err);
 
                 warning("%s failed to instantiate engine: %s (target '%s', path '%s')",
                         plugin->getName(),
@@ -392 +386 @@
                         // Did an error occur ?
                         if (result != Common::kNoError) {
                                 // TODO: Show an informative error dialog if starting the selected game failed.
+                                // Done (Covers more error values than that in runGame()).
+                                Common::displayErrorDialog(result, "Error running game:");
                         }
 
                         // Quit unless an error occurred, or Return to launcher was requested
@@ -418 +414 @@
                         // A dialog would be nicer, but we don't have any
                         // screen to draw on yet.
                         warning("Could not find any engine capable of running the selected game");
+                        Common::displayErrorDialog("Could not find any engine capable of running the selected game");
                 }
 
                 // We will destroy the AudioCDManager singleton here to save some memory.