Losing double precision when dealing with timestamps - objective-c

Question

I have a simple XCTestCase:
func testExample() {
let date = "2015-09-21T20:38:54.379912Z";// as NSString;
let date1 = 1442867934.379912;
XCTAssertEqual(date1, NSDate.sam_dateFromISO8601String(date).timeIntervalSince1970);
}
This test passes, when it shouldn't, for two reasons:
1442867934.379912 becomes 1442867934.379911 in the test, even though its literally just a variable re-printed
the sam_ function (copied below) seems to think the same way, the millisecond variable becomes millisecond double 0.37991200000000003 0.37991200000000003 which when later converted from NSDate to double, seems to lose the microsecond precision (debugger):
po NSDate.sam_dateFromISO8601String(date).timeIntervalSince1970 -> 1442867934.37991
po 1442867934.379912 -> 1442867934.37991
Any idea why? The microsecond precision (6 decimal places) is really important to my application, I need to seamlessly convert to and from NSString and NSDate using the iso8601 format.
+ (NSDate *)sam_dateFromISO8601String:(NSString *)iso8601 {
// Return nil if nil is given
if (!iso8601 || [iso8601 isEqual:[NSNull null]]) {
return nil;
}
// Parse number
if ([iso8601 isKindOfClass:[NSNumber class]]) {
return [NSDate dateWithTimeIntervalSince1970:[(NSNumber *)iso8601 doubleValue]];
}
// Parse string
else if ([iso8601 isKindOfClass:[NSString class]]) {
const char *str = [iso8601 cStringUsingEncoding:NSUTF8StringEncoding];
size_t len = strlen(str);
if (len == 0) {
return nil;
}
struct tm tm;
char newStr[25] = "";
BOOL hasTimezone = NO;
// 2014-03-30T09:13:00Z
if (len == 20 && str[len - 1] == 'Z') {
strncpy(newStr, str, len - 1);
}
// 2014-03-30T09:13:00-07:00
else if (len == 25 && str[22] == ':') {
strncpy(newStr, str, 19);
hasTimezone = YES;
}
// 2014-03-30T09:13:00.000Z
else if (len == 24 && str[len - 1] == 'Z') {
strncpy(newStr, str, 19);
}
// 2014-03-30T09:13:00.000000Z
else if (len == 27 && str[len - 1] == 'Z') {
strncpy(newStr, str, 19);
}
// 2014-03-30T09:13:00.000-07:00
else if (len == 29 && str[26] == ':') {
strncpy(newStr, str, 19);
hasTimezone = YES;
}
// Poorly formatted timezone
else {
strncpy(newStr, str, len > 24 ? 24 : len);
}
// Timezone
size_t l = strlen(newStr);
if (hasTimezone) {
strncpy(newStr + l, str + len - 6, 3);
strncpy(newStr + l + 3, str + len - 2, 2);
} else {
strncpy(newStr + l, "+0000", 5);
}
// Add null terminator
newStr[sizeof(newStr) - 1] = 0;
if (strptime(newStr, "%FT%T%z", &tm) == NULL) {
return nil;
}
double millisecond = 0.0f;
NSString *subStr = [[iso8601 componentsSeparatedByString:#"."].lastObject substringToIndex:6];
millisecond = subStr.doubleValue/1000000.f;
time_t t;
t = mktime(&tm);
return [NSDate dateWithTimeIntervalSince1970:t + millisecond];
}
NSAssert1(NO, #"Failed to parse date: %#", iso8601);
return nil;
}

Answer 1

1442867934.379912 and 1442867934.379911 may very well equal the same number just printed differently (one rounded, the other truncated)... if microsecond time is important to you, perhaps you should look at https://developer.apple.com/library/mac/qa/qa1398/_index.html
especially because [NSDate date] can change wildly when the clock changes... and an absolute time api will not...

Answer 2

I ended up simply changing my API to pass double representation of a Time object. i.e. 1442867934.379912not messing with ISO8601 at all.
NSDate supports this natively. So I don't have to parse any strings. Therefore, performance is an added bonus.
A couple quirks I encountered while doing this in Rails/Rabl/Oj:
Need to send the double as a string. It seems the JSONKit on iOS doesn't like more than 15 significant digits, and neither does the JSON spec.
Rabl (initializer):
Oj.default_options = {
use_to_json: true,
second_precision: 6,
float_precision: 16
}
The default to_f was not sending the precision I needed.