def test_simple_add(self):

        # Add one slot together with a timespan
        allocation = Allocation(raster=15, resource=uuid())
        allocation.start = datetime(2011, 1, 1, 15)
        allocation.end = datetime(2011, 1, 1, 15, 59)
        allocation.group = uuid()

        reservation = uuid()

        slot = ReservedSlot(resource=allocation.resource)
        slot.start = allocation.start
        slot.end = allocation.end
        slot.allocation = allocation
        slot.reservation = reservation
        allocation.reserved_slots.append(slot)

        # Ensure that the same slot cannot be doubly used
        anotherslot = ReservedSlot(resource=allocation.resource)
        anotherslot.start = allocation.start
        anotherslot.end = allocation.end
        anotherslot.allocation = allocation
        anotherslot.reservation = reservation

        Session.add(anotherslot)
        self.assertRaises(IntegrityError, Session.flush)

def get_visitor_id():
    prev_visitors= set(os.listdir(results_dir))

    new_id= uuid().hex
    while new_id in prev_visitors: new_id=uuid().hex

    return new_id

 def __init__(self, *args, **kwargs):
     fk_fs_type = kwargs.get('fk_fs_type', None)
     if fk_fs_type != None:
        self.fk_fs_type = uuid.uuid()
     fs_uuid = kwargs.get('fs_uuid', None)
     if fs_uuid != None:
        self.fs_uuid = uuid.uuid()

def getLock(name = None):
	if not name:
		name = str(uuid())
		while name in locks:
			name = str(uuid())
	if not name in locks:
		locks[name] = SingleLock() if name[0] == '#' else ReentLock()
	return locks[name]

 def test_export(self):
     commitish = uuid().hex
     dest = '/home/' + uuid().hex
     self.git.export(commitish, dest)
     self.subprocess.assertExistsCommand(
         lambda c: c.startswith('git archive') and commitish in c)
     self.subprocess.assertExistsCommand(
         lambda c: dest in c)

def add_something(resource=None):
    resource = resource or uuid()
    allocation = Allocation(raster=15, resource=resource, mirror_of=resource)
    allocation.start = datetime(2011, 1, 1, 15)
    allocation.end = datetime(2011, 1, 1, 15, 59)
    allocation.group = uuid()

    Session.add(allocation)

 def _create_allocation(self):
     allocation = Allocation(raster=15, resource=uuid())
     allocation.start = datetime(2011, 1, 1, 15, 00)
     allocation.end = datetime(2011, 1, 1, 16, 00)
     allocation.group = str(uuid())
     allocation.mirror_of = allocation.resource
     Session.add(allocation)
     return allocation

 def test_local_config(self):
     k = uuid().hex
     v = uuid().hex
     self.git.set_local_config(k, v)
     self.subprocess.assertLastCommandStartsWith('git config')
     self.subprocess.assertLastCommandContains(k)
     pred = lambda c: c.startswith('git config') and k in c
     self.subprocess.provideResult(pred, v)
     self.assertEqual(v, self.git.get_local_config(k))

 def write(self):
     message_header = ET.Element('MessageHeader')
     self.__add_element_with_text(message_header, "MessageThreadId", str(uuid()))
     self.__add_element_with_text(message_header, "MessageId", str(uuid()))
     message_header.append(self.sender.write())
     message_header.append(self.recipient.write())
     created_date = ET.SubElement(message_header, "MessageCreatedDateTime")
     created_date.text = d.datetime.now().replace(microsecond=0).isoformat()+ "Z" 
     return message_header

    def setUp(self):
        super(TestExternalLedgerEntryWithFullName, self).setUp()
        self.currency = CurrencyModel.query.filter_by(code='USD').first()
        self.fee = FeeModel.query.get(1)

        n = uuid().hex
        self.user = self.create_user(n, '%s %s' % (n[:16], n[16:]))
        self.user_balance = self.create_balance(user=self.user, currency_code='USD')

        self.campaign = self.create_campaign(uuid().hex, uuid().hex)
        self.campaign_balance = self.create_balance(campaign=self.campaign, currency_code='USD')

    def make_commit(self):
        """
        Makes a random commit in the current branch.
        """
        fragment = uuid().hex[:8]
        filename = join(self.repodir, fragment)
        with open(filename, 'w') as fh:
            fh.write(uuid().hex)

        self.repo.index.add([basename(filename)])
        self.repo.index.commit('Adding {0}'.format(basename(filename)))

    def __init__(self, server, port=6667, nick="", realname=""):
        self.server = server
        self.port = 6667
        self.nickname = nick
        self.realname = nick
        self.conn = None
        self.version = "IRC python generic custom bot 2014"

        self.events= {
                      "ctcp":{
                              uuid(): lambda is_request, origin, command, message: None if command.upper()!="PING" else self.ctcp_reply(origin,command,(message,)),
                              uuid(): lambda is_request, origin, command, message: None if command.upper()!="VERSION" else self.ctcp_reply(origin,command,(self.version,))
                             }
                      }

    def setUp(self):
        self.SMTP_patcher = patch("pooldlib.api.communication.mail.smtplib")
        self.SMTP_patcher.start()
        self.email = email.Email(None, None)
        self.addCleanup(self.SMTP_patcher.stop)

        self.username_a = uuid().hex
        self.name_a = "%s %s" % (self.username_a[:16], self.username_a[16:])
        self.email_a = "%[email protected]" % self.username_a
        self.user_a = self.create_user(self.username_a, self.name_a, self.email_a)

        self.username_b = uuid().hex
        self.name_b = "%s %s" % (self.username_b[:16], self.username_b[16:])
        self.email_b = "%[email protected]" % self.username_b
        self.user_b = self.create_user(self.username_b, self.name_b, self.email_b)

def getCounter(name = None, start = 0, unique = False):
	if name:
		base = name
		idx = 1
		while unique and name in counters:
			idx += 1
			name = "%s-%d" % (base, idx)
	else:
		name = str(uuid())
		while name in counters:
			name = str(uuid())

	if not name in counters:
		counters[name] = Counter(start)
	return counters[name]

def generate():
    width = 720
    height = 300
    white = (255, 255, 255)

    rexp = ["sin(pi*i/x)","cos(pi*i/x)"][randint(0,1)]
    gexp = ["cos((pi*i*j)/x)","sin((pi*i*j)/x)"][randint(0,1)]
    bexp = ["sin(pi*j/x)","cos(pi*j/x)"][randint(0,1)]
    tileSize = randint(2,5) 
    x = float([3,5,7,11,13,17,19,21][randint(0,7)]) 

    image = Image.new("RGB", (width, height), white)
    draw = ImageDraw.Draw(image)

    for i in xrange(0,720,tileSize):
        for j in xrange(0,480,tileSize):
            r = int(eval(rexp)*1000%255)
            g = int(eval(gexp)*1000%255)
            b = int(eval(bexp)*1000%255)

            tileColor = "#"+hex(r)[2:].zfill(2)+hex(g)[2:].zfill(2)+hex(b)[2:].zfill(2)
            draw.rectangle([(i,j),(i+tileSize,j+tileSize)], tileColor, None)

    path = "static/img/"
    fileName = str(uuid().int)+".jpg"
    image.save(path+fileName, 'JPEG')

    return path+fileName

    def add_handler(self, event_name, handler):
        id= uuid()
        if event_name in self.events.keys():
            self.events[event_name][id] = handler
        else: self.events[event_name] = {id: handler}

        return id

def canvas1(name=None, x=750, y=535):
    """
    creates a new TCanvas 750px wide, usual aspect ratio
    """
    title = name or str(uuid())
    c =  ROOT.TCanvas(title, title, x, y)
    return c

def pre_save_parameter(sender, **kwargs):

    # the object can be accessed via kwargs 'instance' key.
    parameter = kwargs['instance']

    if parameter.name.units.startswith('image') \
            and parameter.name.data_type == ParameterName.FILENAME:
        if parameter.string_value:
            from base64 import b64decode
            from os import mkdir
            from os.path import exists, join
            from uuid import uuid4 as uuid

            exp_id = parameter.getExpId()

            dirname = join(settings.FILE_STORE_PATH, str(exp_id))
            filename = str(uuid())
            filepath = join(dirname, filename)

            b64 = parameter.string_value
            modulo = len(b64) % 4
            if modulo:
                b64 += (4 - modulo) * '='

            if not exists(dirname):
                mkdir(dirname)
            f = open(filepath, 'w')
            try:
                f.write(b64decode(b64))
            except TypeError:
                f.write(b64)
            f.close()
            parameter.string_value = filename

    def start(self, process=False, link=None):
        """
        Start a new thread or process that invokes this manager's
        ``run()`` method. The invocation of this method returns
        immediately after the task or process has been started.
        """

        if process:
            # Parent<->Child Bridge
            if link is not None:
                from circuits.net.sockets import Pipe
                from circuits.core.bridge import Bridge

                channels = (uuid(),) * 2
                parent, child = Pipe(*channels)
                bridge = Bridge(parent, channel=channels[0]).register(link)

                args = (child,)
            else:
                args = ()
                bridge = None

            self.__process = Process(target=self.run, args=args, name=self.name)
            self.__process.daemon = True
            self.__process.start()

            return self.__process, bridge
        else:
            self.__thread = Thread(target=self.run, name=self.name)
            self.__thread.daemon = True
            self.__thread.start()

            return self.__thread, None

 def __init__(self, *args, **kwargs):
     super(YahooContactImporter, self).__init__(*args, **kwargs)
     self.request_token_url = REQUEST_TOKEN_URL
     self.request_auth_url = REQUEST_AUTH_URL
     self.token_url = TOKEN_URL
     self.oauth_timestamp = int(time())
     self.oauth_nonce = md5("%s%s" % (uuid(), self.oauth_timestamp)).hexdigest()