env["CCFLAGS"] = env.get("ccflags", [])

env["LINKFLAGS"] = env.get("linkflags", [])

if env["optimize"] :

env.Append(CCFLAGS = "-O2")

if env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["GL"])

env.Append(LINKFLAGS = ["/INCREMENTAL:NO", "/LTCG"])

if env["debug"] :

if env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/Zi", "/MDd"])

env.Append(LINKFLAGS = ["/DEBUG"])

else :

env.Append(CCFLAGS = "-g")

elif env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/MD"])

if env.get("universal", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-isysroot", "/Developer/SDKs/MacOSX10.4u.sdk",

"-arch", "i386",

"-arch", "ppc"])

env.Append(LINKFLAGS = [

"-mmacosx-version-min=10.4",

"-Wl", "-syslibroot,/Developer/SDKs/MacOSX10.4u.sdk",

"-arch", "i386",

"-arch", "ppc"])

if env["warnings"] :

if env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/Wall"])

else :

env.Append(CCFLAGS = ["-W", "-Wall"])

#env.Append(CCFLAGS = ["-W", "-Wall", "-Wredundant-decls", "-pedantic", "-Wno-long-long", "-Woverloaded-virtual", "-Wundef", "-Wfloat-equal", "-Wold-style-cast"])

if env.get("coverage", 0) :

assert(env["PLATFORM"] != "win32")

env.Append(CCFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

env.Append(LINKFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

if env["PLATFORM"] == "win32" :

env.Append(LIBS = ["dnsapi", "ws2_32", "wsock32"])

env.Append(CCFLAGS = ["/EHsc", "/nologo"])

env["LINKCOM"] = [env["LINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;1']

env["SHLINKCOM"] = [env["SHLINKCOM"], 'mt.exe -nologo -manifest ${TARGET}.manifest -outputresource:$TARGET;2']

if env["PLATFORM"] == "darwin" :

# Testing

env["TEST_TYPE"] = env["test"]

env.Alias("check", ".")

if "check" in ARGUMENTS or "check" in COMMAND_LINE_TARGETS :

env["TEST_TYPE"] = "unit"

env["TEST"] = (env["TEST_TYPE"] != "none") or env.GetOption("clean")

if env.get("valgrind", 0) :

env["TEST_RUNNER"] = "valgrind --suppressions=QA/valgrind.supp -q --leak-check=full --track-origins=yes "

# Packaging

if ARGUMENTS.get("SWIFT_INSTALLDIR", "") :

env["SWIFT_INSTALLDIR"] = Dir(ARGUMENTS["SWIFT_INSTALLDIR"]).abspath

conf_env = env.Clone()

Export("env")

Export("conf_env")

################################################################################

# Extend the default build environment (not affecting the configure env)

#

# Keeping both environments separated mostly because of SCons Issue 2391,

# although it doesn't hurt to separate them (e.g. not have pretty printed

# strings in config.log)

################################################################################

#if env["PLATFORM"] == "win32" :

# env["MSVC_BATCH"] = 1

# Pretty output

def colorize(command, target, color) :

colors = { "red": "31", "green": "32", "yellow": "33", "blue": "34" }

prefix = ""

suffix = ""

if sys.stdout.isatty() and env["PLATFORM"] != "win32":

prefix = "\033[0;" + colors[color] + ";140m"

suffix = "\033[0m"

return " " + prefix + command + suffix + " " + target

if int(ARGUMENTS.get("V", 0)) == 0:

env["CCCOMSTR"] = colorize("CC", "$TARGET", "green")

env["CXXCOMSTR"] = colorize("CXX", "$TARGET", "green")

env["LINKCOMSTR"] = colorize("LINK", "$TARGET", "red")

env["ARCOMSTR"] = colorize("AR", "$TARGET", "red")

env["RANLIBCOMSTR"] = colorize("RANLIB", "$TARGET", "red")

env["QT4_RCCCOMSTR"] = colorize("RCC", "$TARGET", "blue")

#include "SwifTools/Idle/PlatformIdleQuerier.h"

#include "SwifTools/Idle/XSSIdleQuerier.h"

#else

#include "SwifTools/Idle/DummyIdleQuerier.h"

#endif

#include <cassert>

#include <iostream>

namespace Swift {

PlatformIdleQuerier::PlatformIdleQuerier() : querier(NULL) {

querier = new XSSIdleQuerier();

#else

querier = new DummyIdleQuerier();

#endif

}

PlatformIdleQuerier::~PlatformIdleQuerier() {

delete querier;

}

}

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <boost/bind.hpp>

#include "SwifTools/Idle/ActualIdleDetector.h"

#include "SwifTools/Idle/IdleQuerier.h"

#include "Swiften/Base/foreach.h"

#include "Swiften/Network/TimerFactory.h"

#include "Swiften/Network/Timer.h"

using namespace Swift;

class ActualIdleDetectorTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ActualIdleDetectorTest);

CPPUNIT_TEST(testDestructor);

CPPUNIT_TEST(testHandleTick_Idle);

CPPUNIT_TEST(testHandleTick_Idle_AlreadyIdle);

CPPUNIT_TEST(testHandleTick_NotIdle);

CPPUNIT_TEST(testHandleTick_NotIdle_AlreadyNotIdle);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

querier = new MockIdleQuerier();

timerFactory = new MockTimerFactory();

idleEvents.clear();

}

void tearDown() {

delete timerFactory;

delete querier;

}

void testDestructor() {

ActualIdleDetector* testling = createDetector();

testling->setIdleTimeSeconds(15);

delete testling;

querier->idleTime = 15;

timerFactory->updateTime(15000);

}

void testHandleTick_Idle() {

std::auto_ptr<ActualIdleDetector> testling(createDetector());

testling->setIdleTimeSeconds(15);

querier->idleTime = 15;

timerFactory->updateTime(15000);

CPPUNIT_ASSERT(idleEvents[0]);

}

void testHandleTick_Idle_AlreadyIdle() {

std::auto_ptr<ActualIdleDetector> testling(createDetector());

testling->setIdleTimeSeconds(15);

querier->idleTime = 15;

timerFactory->updateTime(15000);

querier->idleTime = 30;

timerFactory->updateTime(30000);

CPPUNIT_ASSERT(idleEvents[0]);

}

void testHandleTick_NotIdle() {

std::auto_ptr<ActualIdleDetector> testling(createDetector());

testling->setIdleTimeSeconds(15);

querier->idleTime = 15;

timerFactory->updateTime(15000);

querier->idleTime = 5;

timerFactory->updateTime(30000);

CPPUNIT_ASSERT(idleEvents[0]);

CPPUNIT_ASSERT(!idleEvents[1]);

}

void testHandleTick_NotIdle_AlreadyNotIdle() {

std::auto_ptr<ActualIdleDetector> testling(createDetector());

testling->setIdleTimeSeconds(15);

querier->idleTime = 5;

timerFactory->updateTime(15000);

}

private:

ActualIdleDetector* createDetector() {

ActualIdleDetector* detector = new ActualIdleDetector(querier, timerFactory, 10);

detector->onIdleChanged.connect(boost::bind(&ActualIdleDetectorTest::handleIdle, this, _1));

return detector;

}

void handleIdle(bool b) {

idleEvents.push_back(b);

}

private:

struct MockIdleQuerier : public IdleQuerier {

MockIdleQuerier() : idleTime(0) {}

virtual int getIdleTimeSeconds() { return idleTime; }

int idleTime;

};

struct MockTimer : public Timer {

MockTimer(int interval) : interval(interval), running(false), lastTime(0) {}

virtual void start() {

running = true;

}

virtual void stop() {

running = false;

}

virtual void updateTime(int currentTime) {

if (lastTime == currentTime) {

return;

}

if (running) {

int time = lastTime;

while (time <= currentTime) {

onTick();

time += interval;

}

}

lastTime = currentTime;

}

int interval;

bool running;

int lastTime;

Import("env")

env["SWIFTOOLS_FLAGS"] = {

"LIBPATH": [Dir(".")],

"LIBS": ["SwifTools"]

}

myenv = env.Clone()

myenv.MergeFlags(myenv["BOOST_FLAGS"])

sources = [

"Idle/IdleDetector.cpp",

"Idle/ActualIdleDetector.cpp",

"Idle/IdleQuerier.cpp",

"Idle/PlatformIdleQuerier.cpp",

"Linkify.cpp",

]

if myenv["PLATFORM"] == "win32" :

pass

elif myenv["PLATFORM"] == "darwin" :

elif myenv["HAVE_XSS"] :

myenv.Append(CPPDEFINES = ["HAVE_XSS"])

sources += ["Idle/XSSIdleQuerier.cpp"]

else :

sources += ["Idle/DummyIdleQuerier.cpp"]

myenv.StaticLibrary("SwifTools", sources)

SConscript(dirs = [

"Idle/IdleQuerierTest",

"Idle/UnitTest",

"UnitTest"

])