[(AnyClass*)[AnyClass alloc] initXY];

// http://blog.mro.name/2010/06/xcode-missing-deprecated-warnings/
#define alloc(c)	((c*)[c alloc])

-(void)testiPhoneSDK312NSKeyedArchiver
{
//  prepare a NSCachedURLResponse
    NSCachedURLResponse *src = nil;
    {
        NSURL *i_url = [NSURL URLWithString:@"http://www.url.example/path/file.html"];
        NSString *i_mime = @"text/html";
        NSInteger expectedContentLength = 112;
        NSString *i_encoding = @"iso-8859-2";
 
        NSURLResponse *i_response = [[NSURLResponse alloc] initWithURL:i_url
            MIMEType:i_mime
            expectedContentLength:expectedContentLength
            textEncodingName:i_encoding];
        NSData *i_data = [@"Hello, world!" dataUsingEncoding:NSISOLatin2StringEncoding];
        NSURLCacheStoragePolicy i_storage =  NSURLCacheStorageAllowed;
        NSDictionary *i_userInfo = [NSDictionary dictionaryWithObject:
        [NSDate dateWithTimeIntervalSince1970:13] forKey:@"era"];
 
        NSCachedURLResponse *src = [[NSCachedURLResponse alloc] initWithResponse:i_response
            data:i_data
            userInfo:i_userInfo
            storagePolicy:i_storage];
 
//      ensure it's all in place:
        STAssertEqualObjects(i_url, src.response.URL, @"");
        STAssertEqualObjects(i_mime, src.response.MIMEType, @"");
        STAssertEquals((int)expectedContentLength, (int)src.response.expectedContentLength, @"");
        STAssertEqualObjects(@"file.html", src.response.suggestedFilename, @"");
        STAssertEqualObjects(i_encoding, src.response.textEncodingName, @"");
 
        STAssertEqualObjects(i_data, src.data, @"");
        STAssertEqualObjects(i_userInfo, src.userInfo, @"");
        STAssertEquals( 0u, src.storagePolicy, @"");
    }
 
//  archive + unarchive:
    NSCachedURLResponse *dst = [NSKeyedUnarchiver unarchiveObjectWithData:
      [NSKeyedArchiver archivedDataWithRootObject:src]];
 
//  check whether src == dst
    STAssertEqualObjects(src.response.URL, dst.response.URL, @"");
    STAssertEqualObjects(src.response.MIMEType, dst.response.MIMEType, @"");
    STAssertEquals(src.response.expectedContentLength, dst.response.expectedContentLength, @"");
    STAssertEqualObjects(src.response.suggestedFilename, dst.response.suggestedFilename, @"");
    STAssertEqualObjects(src.response.textEncodingName, dst.response.textEncodingName, @"");
 
//  !!!!!!!!!!
//  sad information loss after unarchiving:
    STAssertNil( dst.data, @"" );
    STAssertNil( dst.userInfo, @"" );
    STAssertEquals( 2u , dst.storagePolicy, @"" );
}

-(NSInteger)binarySearch:(id)key;
-(NSInteger)binarySearch:(id)key usingSelector:(SEL)comparator;
-(NSInteger)binarySearch:(id)key usingSelector:(SEL)comparator inRange:(NSRange)range;
-(NSInteger)binarySearch:(id)key usingFunction:(NSInteger (*)(id, id, void *))comparator context:(void *)context;
-(NSInteger)binarySearch:(id)key usingFunction:(NSInteger (*)(id, id, void *))comparator context:(void *)context inRange:(NSRange)range;
-(NSInteger)binarySearch:(id)key usingDescriptors:(NSArray *)sortDescriptors;
-(NSInteger)binarySearch:(id)key usingDescriptors:(NSArray *)sortDescriptors inRange:(NSRange)range;

-(NSInteger)binarySearch:(id)key usingFunction:(NSInteger (*)(id, id, void *))comparator context:(void *)context inRange:(NSRange)range
{
    NSLogD(@"[NSArray(MroBinarySearch) binarySearch:%@ usingFunction:]", key);
    if(self.count == 0 || key == nil || comparator == NULL)
        return [self binarySearch:key usingSelector:nil inRange:range];
 
//	check overflow?
    NSInteger min = range.location;
    NSInteger max = range.location + range.length - 1;
 
    while (min < = max)
    {
        // http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html
        const NSInteger mid = min + (max - min) / 2;
        switch (comparator(key, [self objectAtIndex:mid], context))
        {
            case NSOrderedSame:
                return mid;
            case NSOrderedDescending:
                min = mid + 1;
                break;
            case NSOrderedAscending:
                max = mid - 1;
                break;
        }
    }
    return -(min + 1);
}

-(NSArray*)entityName:(NSString*)entityName findManyByRelation:(NSDictionary*)dict
{
//  TODO handle dict nil and emptyness
    NSMutableArray *arr = [[NSMutableArray alloc] initWithCapacity:dict.count];
    for(NSString *key in dict)
    {
        NSExpression *left = [NSExpression expressionForKeyPath:key];
        NSExpression *right = [NSExpression expressionForConstantValue:[dict objectForKey:key]];
        NSComparisonPredicate *cp = [[NSComparisonPredicate alloc] initWithLeftExpression:left
            rightExpression:right modifier:NSDirectPredicateModifier type:NSEqualToPredicateOperatorType options:0];
        [arr addObject:cp];
        [cp release];
    }
    NSPredicate *pred = nil;
    if(arr.count == 1)
        pred = [[arr objectAtIndex:0] retain];    // why do I have to retain here?
    else
        pred = [[NSCompoundPredicate alloc] initWithType:NSAndPredicateType subpredicates:arr];
 
    NSFetchRequest *fr = [[NSFetchRequest alloc] init];
    fr.entity = [NSEntityDescription entityForName:entityName inManagedObjectContext:self];
    fr.predicate = pred;
    [arr release];
    [pred release];
//	NSLog(@"predicate effective: %@", fr.predicate);
 
    NSError *err = nil;
    NSArray *ps = [self executeFetchRequest:fr error:&err];
    if(err != nil)
        [NSException raise:@"DB Error" format:@"Fetch problem %@", fr.predicate.predicateFormat];
    [fr release];
    return ps;
}

-(NSManagedObject*)entityName:(NSString*)entityName findByPrimaryKey:(NSDictionary*)dict
{
    NSArray *ps = [self entityName:entityName findManyByRelation:dict];
    if(ps == nil || ps.count == 0)
        return nil;
    if (ps.count == 1)
        return [ps objectAtIndex:0];
    [NSException raise:@"DB Error" format:@"Multiple hits for %@", dict];
    return (NSManagedObject*)1/0;
}

-(NSManagedObject*)entityName:(NSString*)entityName selectOrInsertWithKey:(NSDictionary*)dict
{
    NSManagedObject *o = [self entityName:entityName findByPrimaryKey:dict];
    if(o == nil)
    {
        NSEntityDescription *ed = [NSEntityDescription entityForName:entityName inManagedObjectContext:self];
        o = [[NSManagedObject alloc] initWithEntity:ed insertIntoManagedObjectContext:self];
        for(NSString *key in dict)
            [o setValue:[dict objectForKey:key] forKey:key];
        [o autorelease];
    }
    return o;
}

-(void)testNSDateFormatterTrap
{
    NSDateFormatter *lower = [[[NSDateFormatter alloc] init] autorelease];
    lower.dateFormat = @"yyyy-MM-dd HH:mm:SS ZZZ";
 
    NSDateFormatter *upper = [[[NSDateFormatter alloc] init] autorelease];
    upper.dateFormat = @"YYYY-MM-dd HH:mm:SS ZZZ";
 
    lower.timeZone = upper.timeZone = [NSTimeZone timeZoneForSecondsFromGMT:0];
 
    NSDate *d = [lower dateFromString:@"1970-01-01 00:00:00 +0000"];
    STAssertEqualObjects(@"1970-01-01 00:00:00 +0000", [lower stringFromDate:d], @"lower iso wrong");
    STAssertEqualObjects(@"1970-01-01 00:00:00 +0000", [upper stringFromDate:d], @"upper iso wrong");
 
    d = [d addTimeInterval:(-60*60)];
 
    STAssertEqualObjects(@"1969-12-31 23:00:00 +0000", [lower stringFromDate:d], @"lower iso wrong");
    STAssertEqualObjects(@"1970-12-31 23:00:00 +0000", [upper stringFromDate:d], @"upper iso wrong");
}

+(NSPredicate*)findBySearchTerm:(NSString*)rawTerm within:(BOOL)within context:(NSManagedObjectContext*)context
{
    NSSet *tokens = [MovieM indexTokens:rawTerm];
    if(tokens == nil || tokens.count < = 0)
        return [NSPredicate predicateWithFormat:@"FALSEPREDICATE"];
    NSMutableArray *preds = [NSMutableArray arrayWithCapacity:tokens.count];
 
    if(within == NO && context != nil)
    {
	// As queries aren't optimised by default we do it ourselves:
	// 1st: find matching entries from the IndexKey table - leveraging it's index:
        NSFetchRequest *fr = [[NSFetchRequest alloc] init];
        fr.entity = [NSEntityDescription entityForName:@"IndexKey" inManagedObjectContext:context];
        NSMutableSet *result = nil;
        NSError *error = nil;
        for(NSString *token in tokens)
        {
	    // BETWEEN uses the table-index while BEGINSWITH does not:
            fr.predicate = [NSPredicate predicateWithFormat:@"key BETWEEN {%@, %@}", token, [MovieM upperBoundSearchString:token]];
            NSArray *keys = [context executeFetchRequest:fr error:&error];
            if(error != nil)
                NSLog(@"Oops: %@", error);
	    // turn IndexKey entries to movies (join up):
            NSArray *movs = [keys valueForKey:@"movie"];
	    // aggregate the results for each token:
            if(result == nil)
                result = [NSMutableSet setWithArray:movs];
            else
                [result intersectSet:[NSSet setWithArray:movs]];
        }
        [fr release];
        return [NSPredicate predicateWithFormat:@"SELF IN %@", result];
    }
 
    NSPredicate *template = nil;
    if(within)
        template = [NSPredicate predicateWithFormat:@"ANY index.key CONTAiNS $searchTerm"];
    else
        template = [NSPredicate predicateWithFormat:@"ANY index.key BEGINSWITH $searchTerm"];
    for(NSString *token in tokens)
    {
        NSDictionary *params = [NSDictionary dictionaryWithObject:token forKey:@"searchTerm"];
        [preds addObject:[template predicateWithSubstitutionVariables:params]];
    }
    return [NSCompoundPredicate andPredicateWithSubpredicates:preds];
}

//  RegExp.h
//
//  Created by Marcus Rohrmoser on 26.08.09.
//  Copyright 2009 Marcus Rohrmoser. All rights reserved.
 
#import < Foundation/Foundation.h >
#import < regex.h >
 
#define REGEXP_NSERROR_DOMAIN   @"regex.h"
#define NSRegExpPatternKey      @"NSRegExpPatternKey"
 
/** Very simple Objective-C Wrapper around the regex.h functions.
 */
@interface RegExp : NSObject
{
    @private
    regex_t * c_regex;
}
 
/** Compile a RegExp.
 @param pattern See regex.h / regcomp for details. ASCII encodeable characters only!
 @param error in case of trouble: REGEXP_NSERROR_DOMAIN, errocode from regcomp
 and userinfo NSLocalizedDescriptionKey and NSRegExpPatternKey.
 @return the regexp or nil in case of error.
 */
+(RegExp*)RegExpWithString:(NSString*)pattern error:(NSError**)error;
 
/**
 Perform a match.
 @param string text to search
 @return nil (no match) or the complete match plus all matching groups.
 */
-(NSArray*)match:(NSString*)string;
 
@end

//  RegExp.m
//
//  Created by Marcus Rohrmoser on 26.08.09.
//  Copyright 2009 Marcus Rohrmoser. All rights reserved.
 
#import "RegExp.h"
 
#define ENCODING NSASCIIStringEncoding
 
/* Currently uses stringWithCString - which is bashed at
 + http://lists.apple.com/archives/cocoa-dev/2004/Nov/msg01643.html, but why?
 + What's wrong with it?
 + */
@implementation RegExp
 
#pragma mark Internal Helpers
 
-(id)initWithParsedPattern:(regex_t*)value_
{
    if ( self = [super init] )
        c_regex = value_;
    return self;
}
 
+(NSError*)errorFromRegExpError:(regex_t*)regex pattern:(NSString*)pattern code:(NSInteger)code
{
    const size_t errbuf_size = 1000;
    char * errbuf = calloc(errbuf_size, sizeof(errbuf[0]));
    regerror(code, regex, errbuf, errbuf_size);
//	regfree(regex);
//	free(regex);
 
    NSString *msg = [NSString stringWithCString:errbuf encoding:NSASCIIStringEncoding];
    NSError *error = [NSError errorWithDomain:REGEXP_NSERROR_DOMAIN code:code
        userInfo:[NSDictionary dictionaryWithObjectsAndKeys:
            pattern,  NSRegExpPatternKey,
            msg,  NSLocalizedDescriptionKey, nil]];
    free(errbuf);
    return error;
}
 
#pragma mark Public Interface
 
+(RegExp*)RegExpWithString:(NSString*)value_ error:(NSError**)error
{
    if(value_ == nil)
        return nil;
    const char * pat_c = [value_ cStringUsingEncoding:ENCODING];
    regex_t * regex = calloc(1, sizeof(regex_t));
    const int ec = regcomp(regex, pat_c, REG_EXTENDED);
    if(ec != 0)
    {
        if(error != nil)
            *error = [RegExp errorFromRegExpError:regex pattern:value_ code:ec];
        regfree(regex);
        free(regex);
        return nil;
    }
    return [[[RegExp alloc] initWithParsedPattern:regex] autorelease];
}
 
-(NSArray*)match:(NSString*)string
{
    if(string == nil)
        return nil;
    const char * c_str = [string cStringUsingEncoding:ENCODING];
    if(c_str == NULL)
        return nil;
    const int count = 1 + c_regex->re_nsub;
    regmatch_t match[count];
    const int ec = regexec(c_regex, c_str, count, match, 0);
    if(ec != 0)
        return nil;
    NSMutableArray *arr = [NSMutableArray arrayWithCapacity:count];
    for(int i = 0; i < count; i++)
    {
        if(match[i].rm_so == -1 && match[i].rm_eo == -1)
            [arr addObject:[NSNull null]];
        else
        {
            const char * start = &c_str[ match[i].rm_so ];
            const int length = match[i].rm_eo - match[i].rm_so;
            [arr addObject:[[[NSString alloc] initWithBytes:start length:length encoding:ENCODING] autorelease]];
        }
    }
    return arr;
}
 
-(void)dealloc
{
    regfree(c_regex);
    free(c_regex);
    [super dealloc];
}
@end

//  RegExpTC.m
//
//  Created by Marcus Rohrmoser on 26.08.09.
//  Copyright 2009 Marcus Rohrmoser. All rights reserved.
 
#include "TargetConditionals.h"
#if !TARGET_IPHONE_SIMULATOR
#warning TestCase ignored when not building for Simulator
#else
 
#import "../Classes/RegExp.h"
 
#import < SenTestingKit/SenTestingKit.h >
 
@interface RegExpTC : SenTestCase
{
 
}
 
@end
 
@implementation RegExpTC
 
-(void)testYouTube
{
    NSError *error = nil;
    RegExp *pat =
[RegExp RegExpWithString:@"http.+\.youtube\.com/(v/|watch\?v=)([A-Za-z0-9._%-]+)" error:&error];
    STAssertNil(error, @"pattern compile");
    STAssertNotNil(pat, @"pattern compile");
 
    NSArray *match = [pat match:@"http://www.youtube.com/v/61wkfmWzLq4&hl=de
&fs=1&rel=0&color1=0x3a3a3a&color2=0x999999&hd=1&border=1"];
    STAssertNotNil(match, @"must match");
    STAssertEquals(3u, match.count, @"one matching subexpression");
    STAssertEqualObjects(@"v/", [match objectAtIndex:1], @"snippet");
    STAssertEqualObjects(@"61wkfmWzLq4", [match objectAtIndex:2], @"snippet");
 
// /youtube.com/watch?v=([A-Za-z0-9._%-]*)[&w;=+_-]*/
 
    match = [pat match:@"http://www.youtube.com/watch?v=61wkfmWzLq4"];
    STAssertNotNil(match, @"must match");
    STAssertEquals(3u, match.count, @"one matching subexpression");
    STAssertEqualObjects(@"watch?v=", [match objectAtIndex:1], @"snippet");
    STAssertEqualObjects(@"61wkfmWzLq4", [match objectAtIndex:2], @"snippet");
 
    match = [pat match:@"http://www.youtube.com/v/61wkfmWzLq4&hl=de&fs=1&"];
    STAssertNotNil(match, @"must match");
    STAssertEqualObjects(@"v/", [match objectAtIndex:1], @"snippet");
    STAssertEqualObjects(@"61wkfmWzLq4", [match objectAtIndex:2], @"snippet");
}
 
-(void)testCocoaOk
{
    NSError *error = nil;
 
    STAssertNil([RegExp RegExpWithString:nil error:&error], @"pattern nil");
    STAssertNil(error, @"pattern must compile ok");
 
    RegExp *reg = [RegExp RegExpWithString:@"http.+\.youtube\.com/v/([^\&]+)\&.*"
error:&error];
    STAssertNil(error, @"pattern must compile ok");
 
    NSString *str = @"http://www.youtube.com/v/61wkfmWzLq4&hl=de&fs=1
&rel=0&color1=0x3a3a3a&color2=0x999999&hd=1&border=1";
    NSArray * match = [reg match:str];
    STAssertNotNil(match, @"must match");
 
    STAssertEquals(2u, match.count, @"two matches expected");
    STAssertEqualObjects(str, [match objectAtIndex:0], @"complete match");
    STAssertEqualObjects(@"61wkfmWzLq4", [match objectAtIndex:1], @"first matching group");
 
    STAssertNil([reg match:nil], @"must not match");
}
 
-(void)testCocoaFail
{
    NSError *error = nil;
    RegExp *reg = [RegExp RegExpWithString:@"" error:&error];
    STAssertNil(reg, @"pattern must fail");
    STAssertNotNil(error, @"pattern must fail");
    STAssertEqualObjects(REGEXP_NSERROR_DOMAIN, error.domain, @"domain check");
    STAssertEquals(REG_EMPTY, error.code, @"code check");
    STAssertEqualObjects(@"empty (sub)expression", error.localizedDescription, @"description check");
    STAssertEqualObjects(@"", [error.userInfo valueForKey:NSRegExpPatternKey], @"pattern info");
}
 
-(void)testRaw
{
    regex_t regex;
    const char * pattern = "http.+\.youtube\.com/v/([^\&]+)\&.*";
    STAssertTrue(0 == regcomp(&regex, pattern, REG_EXTENDED), @"RegExp compile");
 
    regmatch_t * match = calloc(1 + regex.re_nsub, sizeof(regmatch_t));
    const char * string = "http://www.youtube.com/v/61wkfmWzLq4&hl=de&fs=1&rel=0
&color1=0x3a3a3a&color2=0x999999&hd=1&border=1";
 
    STAssertTrue(0 == regexec(&regex, string, 1 + regex.re_nsub, match, 0), @"RegExp Match");
    STAssertTrue(1 == regex.re_nsub, @"Matching groups count");
 
    STAssertTrue(0 == match[0].rm_so, @"Match 0 start");
    STAssertTrue(127 == match[0].rm_eo, @"Match 0 start");
 
    STAssertTrue(25 == match[1].rm_so, @"Match 1 start");
    STAssertTrue(36 == match[1].rm_eo, @"Match 1 start");
 
    free(match);
    regfree(&regex);
}
 
@end
#endif

NSString *src = @"Fri, 14 Aug 2009 14:45:31 GMT";

NSDateFormatter *df = [[NSDateFormatter alloc] init];
df.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"GMT"];
df.dateFormat = @"EEE',' dd MMM yyyy HH':'mm':'ss 'GMT'";

df.locale = [[[NSLocale alloc] initWithLocaleIdentifier:@"en_US"] autorelease];

#import 
 
/** Category on NSDate to support rfc1123 formatted date strings.
 http://blog.mro.name/2009/08/nsdateformatter-http-header/ and
 http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
 */
@interface NSDate (NSDateRFC1123)
 
/**
 Convert a RFC1123 'Full-Date' string
 (http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1)
 into NSDate.
 */
+(NSDate*)dateFromRFC1123:(NSString*)value_;
 
/**
 Convert NSDate into a RFC1123 'Full-Date' string
 (http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1).
 */
-(NSString*)rfc1123String;
 
@end
 
@implementation NSDate (NSDateRFC1123)
 
+(NSDate*)dateFromRFC1123:(NSString*)value_
{
    if(value_ == nil)
        return nil;
    static NSDateFormatter *rfc1123 = nil;
    if(rfc1123 == nil)
    {
        rfc1123 = [[NSDateFormatter alloc] init];
        rfc1123.locale = [[[NSLocale alloc] initWithLocaleIdentifier:@"en_US"] autorelease];
        rfc1123.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"GMT"];
        rfc1123.dateFormat = @"EEE',' dd MMM yyyy HH':'mm':'ss z";
    }
    NSDate *ret = [rfc1123 dateFromString:value_];
    if(ret != nil)
        return ret;
 
    static NSDateFormatter *rfc850 = nil;
    if(rfc850 == nil)
    {
        rfc850 = [[NSDateFormatter alloc] init];
        rfc850.locale = rfc1123.locale;
        rfc850.timeZone = rfc1123.timeZone;
        rfc850.dateFormat = @"EEEE',' dd'-'MMM'-'yy HH':'mm':'ss z";
    }
    ret = [rfc850 dateFromString:value_];
    if(ret != nil)
        return ret;
 
    static NSDateFormatter *asctime = nil;
    if(asctime == nil)
    {
        asctime = [[NSDateFormatter alloc] init];
        asctime.locale = rfc1123.locale;
        asctime.timeZone = rfc1123.timeZone;
        asctime.dateFormat = @"EEE MMM d HH':'mm':'ss yyyy";
    }
    return [asctime dateFromString:value_];
}
 
-(NSString*)rfc1123String
{
    static NSDateFormatter *df = nil;
    if(df == nil)
    {
        df = [[NSDateFormatter alloc] init];
        df.locale = [[[NSLocale alloc] initWithLocaleIdentifier:@"en_US"] autorelease];
        df.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"GMT"];
        df.dateFormat = @"EEE',' dd MMM yyyy HH':'mm':'ss 'GMT'";
    }
    return [df stringFromDate:self];
}
 
@end
 
//////////////////////////////////////////////////////////
// A testcase to try things out.
//////////////////////////////////////////////////////////
 
#import 
 
/**
 http://blog.mro.name/2009/08/nsdateformatter-http-header/ and
 http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
 */
@interface NSDateFormatterTC : SenTestCase
{
 
}
 
@end
 
@implementation NSDateFormatterTC
 
-(void)testAsctime
{
    STAssertEqualObjects(@"Sun, 06 Nov 1994 08:49:37 GMT",
        [[NSDate dateFromRFC1123:@"Sun Nov  6 08:49:37 1994"] rfc1123String], @"fail");
    STAssertEqualObjects(@"Wed, 16 Nov 1994 08:49:37 GMT",
        [[NSDate dateFromRFC1123:@"Wed Nov 16 08:49:37 1994"] rfc1123String], @"fail");
}
 
-(void)testRFC850
{
    STAssertEqualObjects(@"Sun, 06 Nov 1994 08:49:37 GMT",
        [[NSDate dateFromRFC1123:@"Sunday, 06-Nov-94 08:49:37 GMT"] rfc1123String], @"fail");
}
 
-(void)testRFC1123
{
    NSString *s = @"Fri, 14 Aug 2009 14:45:31 GMT";
    STAssertEqualObjects(s, [[NSDate dateFromRFC1123:s] rfc1123String], @"fail");
 
    s = @"Sun, 06 Nov 1994 08:49:37 GMT";
    STAssertEqualObjects(s, [[NSDate dateFromRFC1123:s] rfc1123String], @"fail");
 
    // a strange asymmetry:
    s = @"Sat, 01 Jan 0001 00:00:00 GMT";
    STAssertEqualObjects(@"Sat, 01 Jan 0001 01:27:48 GMT",
        [[NSDate dateFromRFC1123:s] rfc1123String], @"fail");
}
 
-(void)testRawRFC1123
{
    NSDateFormatter *rfc1123 = [[NSDateFormatter alloc] init];
    rfc1123.locale = [[[NSLocale alloc] initWithLocaleIdentifier:@"en_US"] autorelease];
    rfc1123.timeZone = [NSTimeZone timeZoneWithAbbreviation:@"GMT"];
    rfc1123.dateFormat = @"EEE',' dd MMM yyyy HH':'mm':'ss 'GMT'";
 
    NSString *s = @"Fri, 14 Aug 2009 14:45:31 GMT";
    STAssertEqualObjects(s, [rfc1123 stringFromDate:[rfc1123 dateFromString:s]], @"fail");
 
    s = @"Sun, 06 Nov 1994 08:49:37 GMT";
    STAssertEqualObjects(s, [rfc1123 stringFromDate:[rfc1123 dateFromString:s]], @"fail");
 
    s = @"Sat, 01 Jan 0001 08:00:00 GMT";
    STAssertEqualObjects(s, [rfc1123 stringFromDate:[rfc1123 dateFromString:s]], @"fail");
 
    [rfc1123 release];
}
@end

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url
    cachePolicy:NSURLRequestReloadIgnoringLocalCacheData
    timeoutInterval:60.0];
// set explicitly:
[request setValue:@"gzip" forHTTPHeaderField:@"Accept-Encoding"];

NSURL *storeUrl = [NSURL fileURLWithPath:
[[self applicationDocumentsDirectory]
stringByAppendingPathComponent: @"CoreDataDemo.sqlite"]];