- When reporting errors from the simulator framework always include the error

testing/iossim/iossim.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import <Foundation/Foundation.h>
 #include <asl.h>
 #include <libgen.h>
 #include <stdarg.h>
 #include <stdio.h>
 
@@ skipping 58 matching lines @@
 // is polled by iossim and written to iossim's stdout using the following
 // polling interval.
 const NSTimeInterval kOutputPollIntervalSeconds = 0.1;
 
 // The path within the developer dir of the private Simulator frameworks.
 NSString* const kSimulatorFrameworkRelativePath =
     @"Platforms/iPhoneSimulator.platform/Developer/Library/PrivateFrameworks/"
     @"iPhoneSimulatorRemoteClient.framework";
 NSString* const kDevToolsFoundationRelativePath =
     @"../OtherFrameworks/DevToolsFoundation.framework";
+NSString* const kSimulatorRelativePath =
+    @"Platforms/iPhoneSimulator.platform/Developer/Applications/"
+    @"iPhone Simulator.app";
+
+// Simulator Error String Key. This can be found by looking in the Simulator's
+// Localizable.strings files.
+NSString* const kSimulatorAppQuitErrorKey = @"The simulated application quit.";
 
 const char* gToolName = "iossim";
 
 void LogError(NSString* format, ...) {
   va_list list;
   va_start(list, format);
 
   NSString* message =
       [[[NSString alloc] initWithFormat:format arguments:list] autorelease];
 
@@ skipping 15 matching lines @@
 
   va_end(list);
 }
 
 }  // namespace
 
 // A delegate that is called when the simulated app is started or ended in the
 // simulator.
 @interface SimulatorDelegate : NSObject <DTiPhoneSimulatorSessionDelegate> {
  @private
-  NSString* stdioPath_;  // weak
+  NSString* stdioPath_;
+  NSString* developerDir_;
   NSThread* outputThread_;
+  NSBundle* simulatorBundle_;
   BOOL appRunning_;
 }
 @end
 
 // An implementation that copies the simulated app's stdio to stdout of this
 // executable. While it would be nice to get stdout and stderr independently
 // from iOS Simulator, issues like I/O buffering and interleaved output
 // between iOS Simulator and the app would cause iossim to display things out
 // of order here. Printing all output to a single file keeps the order correct.
 // Instances of this classe should be initialized with the location of the
 // simulated app's output file. When the simulated app starts, a thread is
 // started which handles copying data from the simulated app's output file to
 // the stdout of this executable.
 @implementation SimulatorDelegate
 
 // Specifies the file locations of the simulated app's stdout and stderr.
-- (SimulatorDelegate*)initWithStdioPath:(NSString*)stdioPath {
+- (SimulatorDelegate*)initWithStdioPath:(NSString*)stdioPath
+                           developerDir:(NSString*)developerDir {
   self = [super init];
-  if (self)
+  if (self) {
     stdioPath_ = [stdioPath copy];
+    developerDir_ = [developerDir copy];
+  }
 
   return self;
 }
 
 - (void)dealloc {
   [stdioPath_ release];
+  [developerDir_ release];
+  [simulatorBundle_ release];
   [super dealloc];
 }
 
 // Reads data from the simulated app's output and writes it to stdout. This
 // method blocks, so it should be called in a separate thread. The iOS
 // Simulator takes a file path for the simulated app's stdout and stderr, but
 // this path isn't always available (e.g. when the stdout is Xcode's build
 // window). As a workaround, iossim creates a temp file to hold output, which
 // this method reads and copies to stdout.
 - (void)tailOutput {
   NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 
   // Copy data to stdout/stderr while the app is running.
   NSFileHandle* simio = [NSFileHandle fileHandleForReadingAtPath:stdioPath_];
   NSFileHandle* standardOutput = [NSFileHandle fileHandleWithStandardOutput];
   while (appRunning_) {
     NSAutoreleasePool* innerPool = [[NSAutoreleasePool alloc] init];
     [standardOutput writeData:[simio readDataToEndOfFile]];
     [NSThread sleepForTimeInterval:kOutputPollIntervalSeconds];
     [innerPool drain];
   }
 
   // Once the app is no longer running, copy any data that was written during
   // the last sleep cycle.
   [standardOutput writeData:[simio readDataToEndOfFile]];
 
   [pool drain];
 }
 
+// Fetches a localized error string from the Simulator.
+- (NSString *)localizedSimulatorErrorString:(NSString*)stringKey {
+  // Lazy load of the simulator bundle.
+  if (simulatorBundle_ == nil) {
+    NSString* simulatorPath = [developerDir_
+        stringByAppendingPathComponent:kSimulatorRelativePath];
+    simulatorBundle_ = [NSBundle bundleWithPath:simulatorPath];
+  }
+  NSString *localizedStr =
+      [simulatorBundle_ localizedStringForKey:stringKey
+                                        value:nil
+                                        table:nil];
+  if ([localizedStr length])
+    return localizedStr;
+  // Failed to get a value, follow Cocoa conventions and use the key as the
+  // string.
+  return stringKey;
+}
+
 - (void)session:(DTiPhoneSimulatorSession*)session
        didStart:(BOOL)started
       withError:(NSError*)error {
   if (!started) {
     // If the test executes very quickly (<30ms), the SimulatorDelegate may not
     // get the initial session:started:withError: message indicating successful
     // startup of the simulated app. Instead the delegate will get a
     // session:started:withError: message after the timeout has elapsed. To
     // account for this case, check if the simulated app's stdio file was
     // ever created and if it exists dump it to stdout and return success.
     NSFileManager* fileManager = [NSFileManager defaultManager];
     if ([fileManager fileExistsAtPath:stdioPath_ isDirectory:NO]) {
       appRunning_ = NO;
       [self tailOutput];
       // Note that exiting in this state leaves a process running
       // (e.g. /.../iPhoneSimulator4.3.sdk/usr/libexec/installd -t 30) that will
       // prevent future simulator sessions from being started for 30 seconds
       // unless the iOS Simulator application is killed altogether.
       [self session:session didEndWithError:nil];
 
       // session:didEndWithError should not return (because it exits) so
       // the execution path should never get here.
       exit(EXIT_FAILURE);
     }
 
-    LogError(@"Simulator failed to start: %@", [error localizedDescription]);
+    LogError(@"Simulator failed to start: \"%@\" (%@:%ld)",
+             [error localizedDescription],
+             [error domain], static_cast<long int>([error code]));
     exit(EXIT_FAILURE);
   }
 
   // Start a thread to write contents of outputPath to stdout.
   appRunning_ = YES;
   outputThread_ = [[NSThread alloc] initWithTarget:self
                                           selector:@selector(tailOutput)
                                             object:nil];
   [outputThread_ start];
 }
 
 - (void)session:(DTiPhoneSimulatorSession*)session
     didEndWithError:(NSError*)error {
   appRunning_ = NO;
   // Wait for the output thread to finish copying data to stdout.
   if (outputThread_) {
     while (![outputThread_ isFinished]) {
       [NSThread sleepForTimeInterval:kOutputPollIntervalSeconds];
     }
     [outputThread_ release];
     outputThread_ = nil;
   }
 
   if (error) {
-    LogError(@"Simulator ended with error: %@", [error localizedDescription]);
-    exit(EXIT_FAILURE);
+    // There appears to be a race condition where sometimes the simulator
+    // framework will end with an error, but the error is that the simulated
+    // app cleanly shut down; try to trap this error and don't fail the
+    // simulator run.
+    NSString* localizedDescription = [error localizedDescription];
+    NSString* ignorableErrorStr =
+        [self localizedSimulatorErrorString:kSimulatorAppQuitErrorKey];
+    if ([ignorableErrorStr isEqual:localizedDescription]) {
+      LogWarning(@"Ignoring that Simulator ended with: \"%@\" (%@:%ld)",
+                 localizedDescription, [error domain],
+                 static_cast<long int>([error code]));
+    } else {
+      LogError(@"Simulator ended with error: \"%@\" (%@:%ld)",
+               localizedDescription, [error domain],
+               static_cast<long int>([error code]));
+      exit(EXIT_FAILURE);
+    }
   }
 
   // Check if the simulated app exited abnormally by looking for system log
   // messages from launchd that refer to the simulated app's PID. Limit query
   // to messages in the last minute since PIDs are cyclical.
   aslmsg query = asl_new(ASL_TYPE_QUERY);
   asl_set_query(query, ASL_KEY_SENDER, "launchd",
                 ASL_QUERY_OP_EQUAL | ASL_QUERY_OP_SUBSTRING);
   asl_set_query(query, ASL_KEY_REF_PID,
                 [[[session simulatedApplicationPID] stringValue] UTF8String],
@@ skipping 363 matching lines @@
 
   // Create the config and simulator session.
   DTiPhoneSimulatorSessionConfig* config = BuildSessionConfig(appSpec,
                                                               systemRoot,
                                                               stdioPath,
                                                               stdioPath,
                                                               appArgs,
                                                               appEnv,
                                                               deviceFamily);
   SimulatorDelegate* delegate =
-      [[[SimulatorDelegate alloc] initWithStdioPath:stdioPath] autorelease];
+      [[[SimulatorDelegate alloc] initWithStdioPath:stdioPath
+                                       developerDir:developerDir] autorelease];
   DTiPhoneSimulatorSession* session = BuildSession(delegate);
 
   // Start the simulator session.
   NSError* error;
   BOOL started = [session requestStartWithConfig:config
                                          timeout:kSessionStartTimeoutSeconds
                                            error:&error];
 
   // Spin the runtime indefinitely. When the delegate gets the message that the
   // app has quit it will exit this program.
-  if (started)
+  if (started) {
     [[NSRunLoop mainRunLoop] run];
-  else
-    LogError(@"Simulator failed to start: %@", [error localizedDescription]);
+  } else {
+    LogError(@"Simulator failed to start:  \"%@\" (%@:%ld)",
+             [error localizedDescription],
+             [error domain], static_cast<long int>([error code]));
+  }
 
   // Note that this code is only executed if the simulator fails to start
   // because once the main run loop is started, only the delegate calling
   // exit() will end the program.
   [pool drain];
   return EXIT_FAILURE;
 }