Ticket #9160: gsoc_scummvm.patch

test/common/tokenizer.h

@@ +1 @@
+#include <cxxtest/TestSuite.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"};
+                int szTokenArray = sizeof(tokenArray) / sizeof(Common::String);
+                for (int i = 0; i < szTokenArray; i++ ) {
+                        // make sure nextToken works correctly
+                        TS_ASSERT_EQUALS(tokenArray[i], strTokenizer.nextToken());
+                }
+
+                // test edgy conditions:
+        
+                // Empty String
+                Common::StringTokenizer strTokenizer_1("");
+                TS_ASSERT_EQUALS("", strTokenizer_1.nextToken());
+                
+                // Empty Delimiter
+                Common::StringTokenizer strTokenizer_2("test String", "");
+                TS_ASSERT_EQUALS("test String", strTokenizer_2.nextToken());
+                
+                // String is the delimiter
+                Common::StringTokenizer strTokenizer_3("abc", "abc");
+                TS_ASSERT_EQUALS("", strTokenizer_3.nextToken());
+                // Tokenizer should be empty
+                TS_ASSERT(strTokenizer_3.empty());
+                
+                // consecutive delimiters in the string
+                Common::StringTokenizer strTokenizer_4("strstr,after all!!", "str, !");
+                TS_ASSERT_EQUALS("af", strTokenizer_4.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

@@ -63 +63 @@
         kReadingFailed,                         ///< Failed creating a (savestate) file
         kWritingFailed,                         ///< Failure to write data -- disk full?
 
-        kUnknownError                           ///< Catch-all error, used if no other error code matches
+        kUnknownError,                          ///< Catch-all error, used if no other error code matches
+        
+        kDefaultArgument            ///< Used as a default argument in displayErrorDialog Function
 };
 
+/**
+ * Maps an error code to equivalent string description
+ * @param error : error code to be converted
+ */
+const char* errToString(Error error);
+
+/**
+ * Displays an error dialog for some error code
+ * @param extraText : extra text to be displayed in addition to default string description
+ * @param error : error code
+ */
+void displayErrorDialog(const char* extraText, Error error = kDefaultArgument);
+
 } // End of namespace Common
 
 #endif //COMMON_ERROR_H

common/error.cpp

@@ +1 @@
+#include "common/error.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't create file" },
+        { kReadingFailed, "Reading failed" },                           
+        { kWritingFailed, "Writing data failed" },              
+
+        { kUnknownError, "Unknown Error" }
+};
+
+const char* errToString(Error error) {
+        int tableSize = sizeof(_errMsgTable) / sizeof(ErrorMessage);
+        
+        for (int i = 0; i < tableSize; i++) {
+                if (error == _errMsgTable[i].error) {
+                        return _errMsgTable[i].errMsg;
+                }
+        }
+
+        return "Unknown Error";
+}
+
+void displayErrorDialog(const char* extraText, Error error) {
+        String errorText(extraText);
+        if (error != kDefaultArgument) {
+                errorText += errToString(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 = errToString(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()).
+                                displayErrorDialog("Error running game: ", result);
                         }
 
                         // Quit unless an error occurred, or Return to launcher was requested
@@ -417 +413 @@
                 } else {
                         // A dialog would be nicer, but we don't have any
                         // screen to draw on yet.
+                        Common::displayErrorDialog("Could not find any engine capable of running the selected game");
                         warning("Could not find any engine capable of running the selected game");
                 }