/* Unit tests for DKPort
   Copyright (C) 2010 Free Software Foundation, Inc.

   Written by:  Niels Grewe <niels.grewe@halbordnung.de>
   Created: June 2010

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02111 USA.

   */
#import <Foundation/NSDebug.h>
#import <Foundation/NSObject.h>
#import "ObjectTesting.h"
#define INCLUDE_RUNTIME_H
#include "../Source/config.h"
#undef INCLUDE_RUNTIME_H

#import "DBusKit/DKProxy.h"
#import "../Source/DKEndpoint.h"
#import "DBusKit/DKPort.h"
#import "DBusKit/NSConnection+DBus.h"

#import <Foundation/NSArray.h>
#import <Foundation/NSException.h>
#import <Foundation/NSThread.h>

#include <unistd.h>

@interface DKProxy (Private)
- (SEL)_unmangledSelector: (SEL)selector
                interface: (NSString**)interface;
- (void)DBusBuildMethodCache;
- (NSDictionary*)_interfaces;
@end

@interface TestDKProxy: NSObject
@end

@interface NSObject (FakeDBusSelectors)
- (NSString*)Introspect;
- (NSString*)GetId;
- (NSString*)Hello;
- (NSString*)ListNames;
- (char*)GetNameOwner: (char*)name;
- (BOOL)NameHasOwner: (NSString*)name;
@end

@implementation DKProxy (ArpWrapping)

- (void)arpWrappedNameHasOwner: (NSString*)name
{
  NSAutoreleasePool *arp = [[NSAutoreleasePool alloc] init];
  NS_DURING
  {
    PASS([(id)self NameHasOwner: name], "-NameHasOwner: returns YES")
  }
  NS_HANDLER
  {
    NSLog(@"Got exception: %@", localException);
    PASS(0, "-NameHasOwner: does not raise an exception")
  }
  NS_ENDHANDLER
  [arp release];
  [NSThread exit];
}
@end


@implementation TestDKProxy
- (void)testSelectorUnmangling
{

  NSString *mangledString = @"_DKIf_org_freedesktop_DBus_DKIfEnd_GetNameOwner:";
  SEL mangledSelector = 0;
  SEL unmangledSel = 0;
  NSString *interface = nil;
  NSConnection *conn = nil;
  id proxy = nil;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  proxy = [conn rootProxy];

  // Call a method to trigger cache generation:
  [proxy NameHasOwner: @"org.freedesktop.DBus"];

  sel_registerName([mangledString UTF8String]);
  mangledSelector = NSSelectorFromString(mangledString);

  unmangledSel = [proxy _unmangledSelector: mangledSelector
                                 interface: &interface];
  PASS_EQUAL(@"GetNameOwner:", NSStringFromSelector(unmangledSel),
             "unmangled selector is correct")
  PASS_EQUAL(@"org.freedesktop.DBus", interface, "interface is correct")
}

- (void)testSendIntrospectMessage
{
  NSConnection *conn = nil;
  id aProxy = nil;
  id returnValue = nil;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  returnValue = [aProxy Introspect];

  PASS(nil != returnValue, "-Introspect works")
  PASS([returnValue isKindOfClass: [NSString class]],
       "-Introspect returns NSString")
  PASS([returnValue length] > 0,
       "length of returned string is greater than zero")
}

- (void)testBuildMethodCache
{
  NSConnection *conn = nil;
  id aProxy = nil;
  NSDictionary *interfaces = nil;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  [aProxy DBusBuildMethodCache];
  interfaces = [aProxy _interfaces];
  PASS(nil != interfaces, "-_interfaces works")
  PASS([interfaces count] > 0, "number of interfaces is greater than zero")
}

- (void)testSendGetId
{
  NSConnection *conn = nil;
  id aProxy = nil;
  id returnValue = nil;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  returnValue = [aProxy GetId];
  PASS(nil != returnValue, "-GetId works")
  PASS([returnValue isKindOfClass: [NSString class]],
       "-GetId returns an NSString")
  PASS([returnValue length] > 0,
       "length of returned string is greater than zero")
}

- (void)testExceptionOnSecondHello
{
  NSConnection *conn = nil;
  id aProxy = nil;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  PASS_EXCEPTION([aProxy Hello], @"DKDBusRemoteErrorException",
                 "sending Hello message raises DKDBusRemoteErrorException")
}

- (void)testUnboxedMethodCall
{
  NSConnection *conn = nil;
  id aProxy = nil;
  char *returnValue = NULL;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  returnValue = [aProxy GetNameOwner: "org.freedesktop.DBus"];
  PASS(NULL != returnValue, "-GetNameOwner: works")
}

- (void)testMixedBoxingStateMethodCall
{
  NSConnection *conn = nil;
  id aProxy = nil;
  BOOL returnValue = NO;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  returnValue = [aProxy NameHasOwner: @"org.freedesktop.DBus"];
  PASS(returnValue, "-NameHasOwner: returns YES")
}

- (void)testProxyAtPath
{
  NSConnection *conn = nil;
  id aProxy = nil;
  id returnValue = nil;
  NSWarnMLog(@"This test is an expected failure if the system message bus is not available!");
  conn = [NSConnection connectionWithReceivePort: [DKPort systemBusPort]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"
                                                                            onBus: DKDBusSystemBus] autorelease]];
  aProxy = [conn proxyAtPath: @"/org/freedesktop/DBus"];

  PASS_RUNS(returnValue = [aProxy Introspect],
            "-Introspect does not raise an exception")


  PASS(nil != returnValue, "-Introspect works")
  PASS([returnValue isKindOfClass: [NSString class]],
       "-Introspect returns an NSString");
  PASS([returnValue length] > 0,
       "length of returned string is greater than zero")
}


- (void)testThreadedMethodCalls
{
  NSConnection *conn = nil;
  id aProxy = nil;
  NSString *name = @"org.freedesktop.DBus";
  NSMutableArray *threads = [NSMutableArray new];
  NSUInteger count = 0;
  NSWarnMLog(@"This test is an expected failure if the session message bus is not available!");
  [DKPort enableWorkerThread];
  conn = [NSConnection connectionWithReceivePort: [DKPort port]
                                        sendPort: [[[DKPort alloc] initWithRemote: @"org.freedesktop.DBus"] autorelease]];
  aProxy = [conn rootProxy];
  /*
   * NOTE: D-Bus does not seem to handle more than five concurrent calls very
   * well and will sometimes start complaining about being OOM.
   */
  for (count = 0; count < 5; count++)
  {
    NSThread *aThread = [[NSThread alloc] initWithTarget: aProxy
                                                selector: @selector(arpWrappedNameHasOwner:)
                                                  object: name];
    [threads addObject: aThread];
    [aThread start];
    [aThread release];
  }
  NSLog(@"Sleeping 6 seconds to allow threads to terminate:");
  sleep(6);
  for (count = 0;count < 5; count++)
  {
    PASS([(NSThread*)[threads objectAtIndex: count] isFinished],
         "threaded call works for thread %"PRIuPTR"", count)
  }
}


@end

@interface TestDKDBus: NSObject
@end
@implementation TestDKDBus
- (void)testGetSessionBus
{
  PASS(nil != [DKDBus sessionBus], "+sessionBus works")
}
- (void)testGetSystemBus
{
  PASS(nil != [DKDBus systemBus], "+systemBus works")
}

- (void)useSessionBus
{
  PASS(nil != [[DKDBus sessionBus] GetId], "-GetId works on session bus")
}

- (void)useSystemBus
{
  PASS(nil != [[DKDBus systemBus] GetId], "-GetId works on system bus")
}
@end

int
main (void)
{
  START_SET("DKProxy")

  TestDKProxy *test = [TestDKProxy new];
  [test testSelectorUnmangling];
  [test testSendIntrospectMessage];
  [test testBuildMethodCache];
  [test testSendGetId];
  [test testExceptionOnSecondHello];
  [test testUnboxedMethodCall];
  [test testMixedBoxingStateMethodCall];
  [test testProxyAtPath];
  [test testThreadedMethodCalls];
  DESTROY(test);

  END_SET("DKProxy")

  START_SET("DKDBus")

  TestDKDBus *test1 = [TestDKDBus new];
  [test1 testGetSessionBus];
  [test1 testGetSystemBus];
  [test1 useSessionBus];
  [test1 useSystemBus];
  DESTROY(test1);

  END_SET("DKDBus")

  return 0;
}