def test_node_repr(self):
a = dllist([None]).first
self.assertEqual(repr(a), "<dllistnode(None)>")
b = dllist([1, None]).first
self.assertEqual(repr(b), "<dllistnode(1)>")
c = dllist(["abc", None]).first
self.assertEqual(repr(c), "<dllistnode('abc')>")
def test_node_repr(self):
a = dllist([None]).first
self.assertEqual(repr(a), '<dllistnode(None)>')
b = dllist([1, None]).first
self.assertEqual(repr(b), '<dllistnode(1)>')
c = dllist(['abc', None]).first
self.assertEqual(repr(c), '<dllistnode(\'abc\')>')
def test_node_str(self):
a = dllist([None, None]).first
self.assertEqual(str(a), "dllistnode(None)")
b = dllist([1, None]).first
self.assertEqual(str(b), "dllistnode(1)")
c = dllist(["abc", None]).first
self.assertEqual(str(c), "dllistnode(abc)")
def test_node_repr(self):
a = dllist([None]).first
self.assertEqual(repr(a), '<dllistnode(None)>')
b = dllist([1, None]).first
self.assertEqual(repr(b), '<dllistnode(1)>')
c = dllist(['abc', None]).first
self.assertEqual(repr(c), '<dllistnode(\'abc\')>')
def test_node_str(self):
a = dllist([None, None]).first
self.assertEqual(str(a), 'dllistnode(None)')
b = dllist([1, None]).first
self.assertEqual(str(b), 'dllistnode(1)')
c = dllist(['abc', None]).first
self.assertEqual(str(c), 'dllistnode(abc)')
def test_node_str(self):
a = dllist([None, None]).first
self.assertEqual(str(a), 'dllistnode(None)')
b = dllist([1, None]).first
self.assertEqual(str(b), 'dllistnode(1)')
c = dllist(['abc', None]).first
self.assertEqual(str(c), 'dllistnode(abc)')
def __init__(self, input_text: str):
# Regular expressions
delimiter_pattern = r'[,:;-]'
delimiter_regex = re.compile(delimiter_pattern)
# Create data structures
self.data = dllist()
self.delimiters = dllist()
# Break apart by sentence
sentences = sent_tokenize(input_text)
for sentence in sentences:
# Add a new linked list for the sentence and delimiters
cur_delimiters = dllist()
cur_sentence = dllist()
# Split by whitespace
t_sentence = sentence.split()
[cur_sentence.append(word) for word in t_sentence]
[
cur_delimiters.append(
[index, delimiter_regex.search(word).group(0)])
for index, word in enumerate(t_sentence)
if delimiter_regex.search(word)
]
# Add it in
self.delimiters.append(cur_delimiters)
self.data.append(cur_sentence)
def test_guards_after_concat(self):
a = dllist([1, 2])
b = dllist([3, 4])
c = a + b
self.assertIsNot(c.first, None)
self.assertEqual(c.first.value, 1)
self.assertIsNot(c.last, None)
self.assertEqual(c.last.value, 4)
def test_guards_after_concat(self):
a = dllist([1, 2])
b = dllist([3, 4])
c = a + b
self.assertIsNot(c.first, None)
self.assertEqual(c.first.value, 1)
self.assertIsNot(c.last, None)
self.assertEqual(c.last.value, 4)
def test_guards_after_concat_inplace(self):
a = dllist([1, 2])
b = dllist([3, 4])
orig_a_first = a.first
a += b
self.assertIs(a.first, orig_a_first)
self.assertEqual(a.first.value, 1)
self.assertIsNot(a.last, None)
self.assertEqual(a.last.value, 4)
def test_guards_after_concat_inplace(self):
a = dllist([1, 2])
b = dllist([3, 4])
orig_a_first = a.first
a += b
self.assertIs(a.first, orig_a_first)
self.assertEqual(a.first.value, 1)
self.assertIsNot(a.last, None)
self.assertEqual(a.last.value, 4)
def test_concat(self):
a_ref = range(0, 1024, 4)
a = dllist(a_ref)
b_ref = range(8092, 8092 + 1024, 4)
b = dllist(b_ref)
ab_ref = dllist(a_ref + b_ref)
c = a + b
self.assertEqual(c, ab_ref)
self.assertEqual(len(c), len(ab_ref))
c = a + b_ref
self.assertEqual(c, ab_ref)
self.assertEqual(len(c), len(ab_ref))
def test_cmp(self):
a = dllist(xrange(0, 1100))
b = dllist(xrange(0, 1101))
c = range(0, 1100)
self.assertEqual(cmp(a, a), 0)
self.assertEqual(cmp(a, b), -1)
self.assertEqual(cmp(b, a), 1)
self.assertEqual(cmp(a, c), 0)
self.assertEqual(cmp(c, a), 0)
self.assertEqual(cmp([], []), 0)
self.assertEqual(cmp([], a), -1)
self.assertEqual(cmp(a, []), 1)
def test_concat(self):
a_ref = range(0, 1024, 4)
a = dllist(a_ref)
b_ref = range(8092, 8092 + 1024, 4)
b = dllist(b_ref)
ab_ref = dllist(a_ref + b_ref)
c = a + b
self.assertEqual(c, ab_ref)
self.assertEqual(len(c), len(ab_ref))
c = a + b_ref
self.assertEqual(c, ab_ref)
self.assertEqual(len(c), len(ab_ref))
def test_cmp(self):
a = dllist(xrange(0, 1100))
b = dllist(xrange(0, 1101))
c = [xrange(0, 1100)]
self.assertEqual(cmp(a, a), 0)
self.assertEqual(cmp(a, b), -1)
self.assertEqual(cmp(b, a), 1)
self.assertEqual(cmp(a, c), 1)
self.assertEqual(cmp(c, a), -1)
self.assertEqual(cmp([], []), 0)
self.assertEqual(cmp([], a), -1)
self.assertEqual(cmp(a, []), 1)
def heavy_hitters(e):
k = int(1.0 / e - 1)
table = {}
inner = dllist()
for i in range(k):
inner.insert([None, 0])
outer = dllist([inner])
min_count = 0
with open("Data.txt") as data:
for line in data:
print line
if not table.has_key(line):
if outer.first.value.first.value[1] == min_count:
victim = outer.first.value.popleft()
if table.has_key(victim[0]) :
table.pop(victim[0], None)
outer.first.value.insert([line, min_count])
table[line] = [outer.first, outer.first.value.last]
if table.has_key(line):
a = table.get(line)
a[1].value[1] += 1
if a[0].next:
if a[0].next.value.first.value[1] == a[1].value[1]:
tl = a[0].next
tn = a[0].value.remove(a[1])
tl.value.appendleft(tn)
table[line] = [tl, tl.value.first]
if a[0].value.size == 0:
outer.remove(a[0])
else:
tn = a[0].value.remove(a[1])
new_inner = dllist()
new_inner.appendleft(tn)
outer.insert(new_inner, after=a[0])
table[line] = [a[0].next, a[0].next.value.first]
if a[0].value.size == 0:
outer.remove(a[0])
else:
tn = a[0].value.remove(a[1])
new_inner = dllist()
new_inner.appendleft(tn)
outer.insert(new_inner, after=a[0])
table[line] = [a[0].next, a[0].next.value.first]
if a[0].value.size == 0:
outer.remove(a[0])
else:
min_count += 1
return table
def test_appendleft(self):
ll = dllist(xrange(4))
ref = dllist([10, 0, 1, 2, 3])
next = ll.nodeat(0)
arg_node = dllistnode(10)
new_node = ll.appendleft(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, None)
self.assertEqual(new_node.next, next)
self.assertEqual(next.prev, new_node)
self.assertEqual(ll.first, new_node)
self.assertEqual(ll, ref)
def test_appendright(self):
ll = dllist(xrange(4))
ref = dllist([0, 1, 2, 3, 10])
prev = ll.nodeat(-1)
arg_node = dllistnode(10)
new_node = ll.appendright(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(ll.last, new_node)
self.assertEqual(ll, ref)
def test_appendleft(self):
ll = dllist(xrange(4))
ref = dllist([10, 0, 1, 2, 3])
next = ll.nodeat(0)
arg_node = dllistnode(10)
new_node = ll.appendleft(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, None)
self.assertEqual(new_node.next, next)
self.assertEqual(next.prev, new_node)
self.assertEqual(ll.first, new_node)
self.assertEqual(ll, ref)
def test_insert_value_after_last(self):
ll = dllist(xrange(4))
ref = dllist([0, 1, 2, 3, 10])
prev = ll.nodeat(3)
arg_node = dllistnode(10)
new_node = ll.insert(arg_node, after=ll.last)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(new_node, ll.last)
self.assertEqual(ll, ref)
def test_appendright(self):
ll = dllist(xrange(4))
ref = dllist([0, 1, 2, 3, 10])
prev = ll.nodeat(-1)
arg_node = dllistnode(10)
new_node = ll.appendright(arg_node)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(ll.last, new_node)
self.assertEqual(ll, ref)
def test_insert_value_after_last(self):
ll = dllist(xrange(4))
ref = dllist([0, 1, 2, 3, 10])
prev = ll.nodeat(3)
arg_node = dllistnode(10)
new_node = ll.insert(arg_node, after=ll.last)
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, None)
self.assertEqual(prev.next, new_node)
self.assertEqual(new_node, ll.last)
self.assertEqual(ll, ref)
def test_concat_empty(self):
empty = dllist()
filled_ref = range(0, 1024, 4)
filled = dllist(filled_ref)
res = empty + empty
self.assertEqual(res, dllist([] + []))
self.assertEqual(len(res), 0)
res = empty + filled
self.assertEqual(res, dllist([] + filled_ref))
self.assertEqual(len(res), len(filled_ref))
res = filled + empty
self.assertEqual(res, dllist(filled_ref + []))
self.assertEqual(len(res), len(filled_ref))
def test_concat_empty(self):
empty = dllist()
filled_ref = range(0, 1024, 4)
filled = dllist(filled_ref)
res = empty + empty
self.assertEqual(res, dllist([] + []))
self.assertEqual(len(res), 0)
res = empty + filled
self.assertEqual(res, dllist([] + filled_ref))
self.assertEqual(len(res), len(filled_ref))
res = filled + empty
self.assertEqual(res, dllist(filled_ref + []))
self.assertEqual(len(res), len(filled_ref))
def test_insert_value_after(self):
ll = dllist(xrange(4))
ref = dllist([0, 1, 10, 2, 3])
prev = ll.nodeat(1)
next = ll.nodeat(2)
arg_node = dllistnode(10)
new_node = ll.insert(arg_node, after=ll.nodeat(1))
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, next)
self.assertEqual(prev.next, new_node)
self.assertEqual(next.prev, new_node)
self.assertEqual(ll, ref)
def test_insert_value_after(self):
ll = dllist(xrange(4))
ref = dllist([0, 1, 10, 2, 3])
prev = ll.nodeat(1)
next = ll.nodeat(2)
arg_node = dllistnode(10)
new_node = ll.insert(arg_node, after=ll.nodeat(1))
self.assertNotEqual(new_node, arg_node)
self.assertEqual(new_node.value, 10)
self.assertEqual(new_node.prev, prev)
self.assertEqual(new_node.next, next)
self.assertEqual(prev.next, new_node)
self.assertEqual(next.prev, new_node)
self.assertEqual(ll, ref)
def test_node_after_del(self):
ll = dllist([1, 2, 3])
node = ll.nodeat(1)
del ll[1]
self.assertIs(node.prev, None)
self.assertIs(node.next, None)
self.assertIs(node.list, None)
def convertPattern(pattern, bpm):
spt = secondsPerTick(bpm, pattern.resolution)
notestore = dllist()
def addnotestore(notedata):
if notedata[2] == False:
for noteidx in xrange(len(notestore)):
if notestore[noteidx][2] == True and notestore[noteidx][
1] == notedata[1]:
note = notestore[noteidx]
del notestore[noteidx]
yield (note[0] * spt, notedata[0] * spt, note[1])
break
else:
print("Starting match not found for ", notedata)
else:
notestore.append(notedata)
for track in pattern:
for event in track:
if isinstance(event, midi.events.NoteOnEvent):
if event.data[1] == 0:
for x in addnotestore((event.tick, event.data[0], False)):
yield x
else:
for x in addnotestore((event.tick, event.data[0], True)):
yield x
elif isinstance(event, midi.events.NoteOffEvent):
for x in addnotestore((event.tick, event.data[0], False)):
yield x
def test_guards_after_remove(self):
ll = dllist([1, 2])
ll.remove(ll.last)
self.assertIs(ll.first, ll.last)
ll.remove(ll.first)
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def __init__(self, id, model_type="TDD"):
self.id = id
self.site_list = dllist()
if (model_type == "TDD"):
self.energy_model = TddRtuModel.TddRtuModel()
else:
self.energy_model = None
self.site_count = 0
self.asset_count = 0
self.x_tons = 0
self.x_evap_hp = 0
self.x_avg_age = 0
self.x_avg_weighted_age = 0
self.x_avg_eer = 0
self.x_avg_weighted_eer = 0
self.n_tons = 0
self.n_evap_hp = 0
self.n_avg_age = 0
self.n_avg_weighted_age = 0
self.n_avg_eer = 0
self.n_avg_weighted_eer = 0
self.pre_kwh_hvac_yearly = 0
self.post_kwh_hvac_yearly = 0
self.sav_kwh_hvac_yearly = 0
self.pre_therms_hvac_yearly = 0
self.post_therms_hvac_yearly = 0
self.sav_therms_hvac_yearly = 0
self.kwh_hvac_reduction_pct = 0
self.ecm_manager = EcmManager.EcmManager()
self.hourly_data_manager = HourlyDataManager.HourlyDataManager()
self.update_input_file_flag = False
def test_node_after_remove(self):
ll = dllist([1, 2, 3])
node = ll.nodeat(1)
ll.remove(node)
self.assertIs(node.prev, None)
self.assertIs(node.next, None)
self.assertIs(node.list, None)
def test_guards_after_remove(self):
ll = dllist([1, 2])
ll.remove(ll.last)
self.assertIs(ll.first, ll.last)
ll.remove(ll.first)
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_node_after_del(self):
ll = dllist([1, 2, 3])
node = ll.nodeat(1)
del ll[1]
self.assertIs(node.prev, None)
self.assertIs(node.next, None)
self.assertIs(node.list, None)
def test_init_empty(self):
ll = dllist()
self.assertEqual(len(ll), 0)
self.assertEqual(ll.size, 0)
self.assertEqual(list(ll), [])
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_node_after_remove(self):
ll = dllist([1, 2, 3])
node = ll.nodeat(1)
ll.remove(node)
self.assertIs(node.prev, None)
self.assertIs(node.next, None)
self.assertIs(node.list, None)
def __init__(self, **kwargs):
super().__init__()
self._tslam = kwargs['tslam']
self._paranoia = 0
# Argument parsing ---------------------------------------------------- {{{
argp = argparse.ArgumentParser()
self._init_add_args(argp)
self._init_handle_args(argp.parse_args(kwargs['cliargs']))
# --------------------------------------------------------------------- }}}
self._pagelog = 12
self._basepg = 1
baseva = self._basepg * 2**self._pagelog
self._brscache = None
self._eva2sst = IntervalMap(baseva, 2**64 - baseva, SegSt.AHWM)
self._eva2sz = {}
self._evp2pst = IntervalMap(self._basepg,
2**(64 - self._pagelog) - self._basepg,
PageSt.UMAP)
self._junklru = dllist()
self._junkadn = {}
self._njunk = 0
self._nmapped = 0
self._npend = 0
self._nwait = 0
self._tidylst = SegFreeList(extcoal=self._sfl_coalesce)
self._wildern = baseva
def __init__(self, **kwargs):
super().__init__()
self._tslam = kwargs['tslam']
# Argument parsing ---------------------------------------------------- {{{
argp = argparse.ArgumentParser()
self._init_add_args(argp)
self._init_handle_args(argp.parse_args(kwargs['cliargs']))
# --------------------------------------------------------------------- }}}
# Power of two, greater than page log
self._bucklog = 16
self._pagelog = 12
self._maxbix = 1 # Next never-touched bucket index (AHWM)
self._szbix2ap = {} # BUMP allocation pointer by size and bix
self._bix2szbm = {} # BUMP and WAIT buckets' size and bitmaps
self._njunkb = 0 # Number of buckets in JUNK state
self._nbwb = 0 # Number of buckets in BUMP|WAIT states
self._bix2state = IntervalMap(self._maxbix,
2**(64 - self._bucklog) - self._maxbix,
BuckSt.AHWM)
self._brscache = None # Biggest revokable span cache
self._junklru = dllist() # List of all revokable spans, LRU
self._junkbdn = {} # JUNK bix to node in above list
def pref_update_callback(self, event):
# copy to lower the chance of chaning size
state_oppo_neigh_temp = {k:v for k, v in self.state_oppo_neigh.items()}
cand_dict = {p: self.get_efficiency(state.x, self.vmax, state.speed)\
for p, state in state_oppo_neigh_temp.items()}
cand_sort = dllist([[k, v] for k, v in sorted(cand_dict.items(), key=lambda x: x[1])])
pin = 0 if cand_sort.size <= self.ub else int(-self.ub)
pref = [n.value[0] for n in cand_sort.nodeat(pin).iternext()] if cand_sort.size > 0 else []
_n = len(pref)
for i in pref[::-1]:
# print(str(self), 'before check neigbour', i, pref)
for d, state in self.state_team_neigh.items():
if i in state.pref and cand_dict[i] < state.pref[i]:
# print(str(self), 'before check neigbour', i, pref)
pref.remove(i)
break;
# nremoved += 1
n_ = len(pref)
for k in range(_n - n_):
if cand_sort.nodeat(pin).prev is None:
break
pref = [cand_sort.nodeat(pin).prev.value[0]] + pref
pin -= 1
pref_dict = {p: cand_dict[p] for p in pref[::-1]}
self.state.pref = pref_dict
self.pref_pub.publish('_'.join(list(map(str, [p + '=%.6f'%e for p, e in pref_dict.items()]))))
def test_init_empty(self):
ll = dllist()
self.assertEqual(len(ll), 0)
self.assertEqual(ll.size, 0)
self.assertEqual(list(ll), [])
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_guards_after_appendright(self):
ll = dllist()
node1 = ll.appendright(1)
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node1)
node2 = ll.appendright(2)
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node2)
def test_guards_after_repeat_inplace(self):
ll = dllist([1, 2])
orig_first = ll.first
orig_last = ll.last
ll *= 4
self.assertIs(ll.first, orig_first)
self.assertIsNot(ll.last, None)
self.assertIsNot(ll.last, orig_last)
def test_guards_after_popright(self):
ll = dllist([1, 2])
ll.pop()
self.assertIs(ll.first, ll.last)
self.assertEqual(ll.first.value, 1)
ll.pop()
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_guards_after_insert(self):
ll = dllist()
node1 = ll.insert(dllistnode(1))
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node1)
node2 = ll.insert(dllistnode(2))
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node2)
def test_guards_after_repeat_inplace(self):
ll = dllist([1, 2])
orig_first = ll.first
orig_last = ll.last
ll *= 4
self.assertIs(ll.first, orig_first)
self.assertIsNot(ll.last, None)
self.assertIsNot(ll.last, orig_last)
def test_guards_after_appendright(self):
ll = dllist()
node1 = ll.appendright(1)
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node1)
node2 = ll.appendright(2)
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node2)
def test_guards_after_insert(self):
ll = dllist()
node1 = ll.insert(dllistnode(1))
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node1)
node2 = ll.insert(dllistnode(2))
self.assertIs(ll.first, node1)
self.assertIs(ll.last, node2)
def test_guards_after_popright(self):
ll = dllist([1, 2])
ll.pop()
self.assertIs(ll.first, ll.last)
self.assertEqual(ll.first.value, 1)
ll.pop()
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_guards_after_del(self):
ll = dllist([1, 2])
orig_last = ll.last
del ll[0]
self.assertIs(ll.first, orig_last)
self.assertIs(ll.last, orig_last)
del ll[0]
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_popright(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
result = ll.popright()
self.assertEqual(result, ref[-1])
self.assertEqual(len(ll), len(ref) - 1)
self.assertEqual(ll.size, len(ref) - 1)
self.assertEqual(ll.last.value, ref[-2])
self.assertEqual(list(ll), ref[:-1])
def test_popright(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
result = ll.popright()
self.assertEqual(result, ref[-1])
self.assertEqual(len(ll), len(ref) - 1)
self.assertEqual(ll.size, len(ref) - 1)
self.assertEqual(ll.last.value, ref[-2])
self.assertEqual(list(ll), ref[:-1])
def test_iternodes(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
idx = 0
for node in ll.iternodes():
self.assertTrue(isinstance(node, dllistnode))
self.assertEqual(node.value, ref[idx])
idx += 1
self.assertEqual(idx, len(ref))
def test_reversed(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
idx = len(ref) - 1
for val in reversed(ll):
self.assertFalse(isinstance(val, dllistnode))
self.assertEqual(val, ref[idx])
idx -= 1
self.assertEqual(idx, -1)
def test_reversed(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
idx = len(ref) - 1
for val in reversed(ll):
self.assertFalse(isinstance(val, dllistnode))
self.assertEqual(val, ref[idx])
idx -= 1
self.assertEqual(idx, -1)
def test_iternext(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
idx = 100
for node in ll.nodeat(idx).iternext():
self.assertTrue(isinstance(node, dllistnode))
self.assertEqual(node.value, ref[idx])
idx += 1
self.assertEqual(idx, len(ref))
def test_popleft(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
result = ll.popleft()
self.assertEqual(result, ref[0])
self.assertEqual(len(ll), len(ref) - 1)
self.assertEqual(ll.size, len(ref) - 1)
self.assertEqual(ll.first.value, ref[1])
self.assertEqual(list(ll), ref[1:])
def test_guards_after_del(self):
ll = dllist([1, 2])
orig_last = ll.last
del ll[0]
self.assertIs(ll.first, orig_last)
self.assertIs(ll.last, orig_last)
del ll[0]
self.assertIs(ll.first, None)
self.assertIs(ll.last, None)
def test_popleft(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
result = ll.popleft()
self.assertEqual(result, ref[0])
self.assertEqual(len(ll), len(ref) - 1)
self.assertEqual(ll.size, len(ref) - 1)
self.assertEqual(ll.first.value, ref[1])
self.assertEqual(list(ll), ref[1:])
def test_iter(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
idx = 0
for val in ll:
self.assertFalse(isinstance(val, dllistnode))
self.assertEqual(val, ref[idx])
idx += 1
self.assertEqual(idx, len(ref))
def test_init_with_sequence(self):
ref = range(0, 1024, 4)
ll = dllist(ref)
self.assertEqual(len(ll), len(ref))
self.assertEqual(ll.size, len(ref))
self.assertEqual(list(ll), ref)
self.assertIsNot(ll.first, None)
self.assertEqual(ll.first.value, 0)
self.assertIsNot(ll.last, None)
self.assertEqual(ll.last.value, 1020)
def test_guards_after_concat_inplace_of_self(self):
ll = dllist([1, 2])
orig_first = ll.first
orig_last = ll.last
ll += ll
self.assertIs(ll.first, orig_first)
self.assertEqual(ll.first.value, 1)
self.assertIsNot(ll.last, None)
self.assertIsNot(ll.last, orig_last)
self.assertEqual(ll.last.value, 2)
