Skip to content

Commit bf2719d

Browse files
jordanmonttjordanmontt
authored
Merge pull request #7 from pankaj-bind/fix-names
class names and code fixed as per conventions
2 parents 270aa73 + 3642a62 commit bf2719d

File tree

6 files changed

+473
-444
lines changed

6 files changed

+473
-444
lines changed

‎README.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,12 +14,12 @@ An implementation of KeyedTree
1414
To have an overview of the features this datastructure provide, have a look at the following code snippet (extracted from a unit test):
1515

1616
```st
17-
firstLevelOneSubTree := KeyedTree new.
17+
firstLevelOneSubTree := CTKeyedTree new.
1818
firstLevelOneSubTree
1919
at: #two put: 'One-Two';
2020
at: #three put: 'One-Three'.
2121
22-
tree := KeyedTree new.
22+
tree := CTKeyedTree new.
2323
tree
2424
at: 1 put: firstLevelOneSubTree;
2525
at: 2 put: 'Two'.

‎src/BaselineOfContainersKeyedTree/BaselineOfContainersKeyedTree.class.st‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,8 @@ Class {
77
{ #category : #baselines }
88
BaselineOfContainersKeyedTree >> baseline: spec [
99
<baseline>
10-
1110
spec for: #pharo do: [
1211
spec package: 'Containers-KeyedTree'.
1312
spec package: 'Containers-KeyedTree-Tests' with: [ spec requires: #('Containers-KeyedTree') ]
1413
]
15-
]
14+
]

‎src/Containers-KeyedTree-Tests/CTKeyedTreeTest.class.st‎

Lines changed: 281 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,281 @@
1+
"
2+
SUnit tests for CTKeyedTree
3+
"
4+
Class {
5+
#name : #CTKeyedTreeTest,
6+
#superclass : #TestCase,
7+
#instVars : [
8+
'tree',
9+
'firstLevelOneSubTree'
10+
],
11+
#category : 'Containers-KeyedTree-Tests'
12+
}
13+
14+
{ #category : #running }
15+
CTKeyedTreeTest >> setUp [
16+
super setUp.
17+
firstLevelOneSubTree := CTKeyedTree new
18+
at: #two put: 'One-Two';
19+
at: #three put: 'One-Three';
20+
yourself.
21+
tree := CTKeyedTree new
22+
at: 1 put: firstLevelOneSubTree;
23+
at: 2 put: 'Two';
24+
yourself
25+
]
26+
27+
{ #category : #'tests - operation' }
28+
CTKeyedTreeTest >> t13 [
29+
^ CTKeyedTree new
30+
at: 1 put: '1-3-1';
31+
at: 2 put: '1-3-2';
32+
yourself
33+
]
34+
35+
{ #category : #'tests - operation' }
36+
CTKeyedTreeTest >> t2 [
37+
^ CTKeyedTree new
38+
at: 1 put: '1-1';
39+
at: 2 put: '1-2';
40+
at: 3 put: (self t13);
41+
yourself
42+
]
43+
44+
{ #category : #'tests - operation' }
45+
CTKeyedTreeTest >> t2AB [
46+
^ CTKeyedTree new
47+
at: 1 put: '1-1';
48+
at: 2 put: '1-2';
49+
at: 3 put: (self tAB);
50+
yourself
51+
]
52+
53+
{ #category : #'tests - operation' }
54+
CTKeyedTreeTest >> tAB [
55+
^ CTKeyedTree new
56+
at: #A put: '1-3-1';
57+
at: #B put: '1-3-2';
58+
yourself
59+
]
60+
61+
{ #category : #'tests - operation' }
62+
CTKeyedTreeTest >> testAllKeys [
63+
self assert: self t13 allKeys asArray equals: #(1 2).
64+
self assert: self t2AB allKeys asArray equals: #(1 2 3 #A #B).
65+
]
66+
67+
{ #category : #'tests - operation' }
68+
CTKeyedTreeTest >> testAllKeysEmptyTree [
69+
| emptyTree |
70+
emptyTree := CTKeyedTree new.
71+
self assert: emptyTree allKeys isEmpty.
72+
]
73+
74+
{ #category : #'tests - at' }
75+
CTKeyedTreeTest >> testAtPath [
76+
self assert: (tree atPath: #(1)) equals: firstLevelOneSubTree.
77+
self assert: (tree atPath: #(1 two)) equals: 'One-Two'.
78+
self assert: (tree atPath: #(1 three)) equals: 'One-Three'.
79+
self assert: (tree atPath: #(2)) equals: 'Two'.
80+
self should: [ tree atPath: #(2 4) ] raise: self defaultTestError.
81+
self should: [ tree atPath: #(1 two three) ] raise: self defaultTestError.
82+
self should: [ tree atPath: #(3) ] raise: self defaultTestError.
83+
]
84+
85+
{ #category : #'tests - at' }
86+
CTKeyedTreeTest >> testAtPathEmpty [
87+
| emptyTree |
88+
emptyTree := CTKeyedTree new.
89+
self should: [ emptyTree atPath: #(1) ] raise: self defaultTestError.
90+
]
91+
92+
{ #category : #tests }
93+
CTKeyedTreeTest >> testAtPathIfAbsent [
94+
"Test accessing elements using a path with an ifAbsent: block."
95+
96+
self assert: (tree atPath: #(1) ifAbsent: [ #missing ]) equals: firstLevelOneSubTree.
97+
self assert: (tree atPath: #(1 two) ifAbsent: [ #missing ]) equals: 'One-Two'.
98+
self assert: (tree atPath: #(1 three) ifAbsent: [ #missing ]) equals: 'One-Three'.
99+
self assert: (tree atPath: #(2) ifAbsent: [ #missing ]) equals: 'Two'.
100+
self assert: (tree atPath: #(2 4) ifAbsent: [ #missing ]) equals: #missing.
101+
self assert: (tree atPath: #(1 two three) ifAbsent: [ #missing ]) equals: #missing.
102+
self assert: (tree atPath: #(3) ifAbsent: [ #missing ]) equals: #missing
103+
]
104+
105+
{ #category : #'tests - at' }
106+
CTKeyedTreeTest >> testAtPathIfAbsentPut [
107+
self assert: (tree atPath: #(1) ifAbsentPut: [ #new ]) equals: firstLevelOneSubTree.
108+
self assert: (tree atPath: #(1 two) ifAbsentPut: [ #new ]) equals: 'One-Two'.
109+
self assert: (tree atPath: #(1 three) ifAbsentPut: [ #new ]) equals: 'One-Three'.
110+
self assert: (tree atPath: #(2) ifAbsentPut: [ #new ]) equals: 'Two'.
111+
self assert: (tree atPath: #(1 four one) ifAbsentPut: [ #anotherNew ]) equals: #anotherNew.
112+
self assert: (tree atPath: #(1 four one)) equals: #anotherNew.
113+
self assert: (tree atPath: #(3) ifAbsentPut: [ #yetAnotherNew ]) equals: #yetAnotherNew.
114+
self assert: (tree atPath: #(3)) equals: #yetAnotherNew.
115+
self should: [ tree atPath: #(2 4) ifAbsentPut: [ #new ] ] raise: self defaultTestError.
116+
]
117+
118+
{ #category : #'tests - at' }
119+
CTKeyedTreeTest >> testAtPathPut [
120+
self assert: (tree atPath: #(1 two) put: #new) equals: #new.
121+
self assert: (tree atPath: #(1 two)) equals: #new.
122+
self assert: (tree atPath: #(1 three) put: (firstLevelOneSubTree := CTKeyedTree new)) equals: firstLevelOneSubTree.
123+
self assert: (tree atPath: #(1 three $1) put: #anotherNew) equals: #anotherNew.
124+
self assert: (tree atPath: #(1 three $1)) equals: #anotherNew.
125+
self assert: (tree atPath: #(1 four one) put: #anotherNew) equals: #anotherNew.
126+
self assert: (tree atPath: #(1 four one)) equals: #anotherNew.
127+
self should: [ tree atPath: #(2 4) put: [ #new ] ] raise: self defaultTestError.
128+
]
129+
130+
{ #category : #'tests - copying' }
131+
CTKeyedTreeTest >> testCopy [
132+
| c t2 t3 |
133+
tree := CTKeyedTree new
134+
at: 1 put: (t2 := CTKeyedTree new
135+
at: #two put: 'One-Two';
136+
at: #three put: 'One-Three';
137+
at: #four put: (t3 := CTKeyedTree new);
138+
yourself);
139+
at: 2 put: 'Two';
140+
yourself.
141+
c := tree copy.
142+
self assert: c = tree.
143+
self deny: c == tree.
144+
self assert: (c at: 1) = t2.
145+
self deny: (c at: 1) == t2.
146+
self assert: (c atPath: #(1 four)) = t3.
147+
self deny: (c atPath: #(1 four)) == t3.
148+
]
149+
150+
{ #category : #'tests - operation' }
151+
CTKeyedTreeTest >> testFormattedText [
152+
self assert: self t13 formattedText equals:
153+
'1 : ''1-3-1''
154+
2 : ''1-3-2''
155+
'.
156+
self assert: self t2AB formattedText equals:
157+
'1 : ''1-1''
158+
2 : ''1-2''
159+
3
160+
#A : ''1-3-1''
161+
#B : ''1-3-2''
162+
'.
163+
]
164+
165+
{ #category : #'tests - operation' }
166+
CTKeyedTreeTest >> testMerge [
167+
| t1 t2 t13 m subT1 subt11 wrapSubt11 |
168+
t13 := self t13.
169+
subT1 := self t2.
170+
subt11 := CTKeyedTree new
171+
at: 1 put: '1-1-1';
172+
at: 2 put: '1-1-2';
173+
yourself.
174+
wrapSubt11 := CTKeyedTree new
175+
at: 1 put: subt11;
176+
at: 2 put: '1-2*';
177+
yourself.
178+
t1 := CTKeyedTree new
179+
at: 1 put: subT1;
180+
at: 2 put: '2';
181+
yourself.
182+
t2 := CTKeyedTree new
183+
at: 1 put: wrapSubt11;
184+
at: 3 put: '3';
185+
yourself.
186+
m := t1 merge: t2.
187+
self assert: (m at: 2) equals: '2'.
188+
self assert: (m at: 3) equals: '3'.
189+
self assert: (m atPath: #(1 2)) equals: '1-2*'.
190+
self assert: (m atPath: #(1 1 1)) equals: '1-1-1'.
191+
self assert: (m atPath: #(1 1 2)) equals: '1-1-2'.
192+
self assert: (m atPath: #(1 3 1)) equals: '1-3-1'.
193+
self assert: (m atPath: #(1 3 2)) equals: '1-3-2'.
194+
]
195+
196+
{ #category : #'tests - copying' }
197+
CTKeyedTreeTest >> testPostCopy [
198+
| original copy subTree |
199+
original := CTKeyedTree new
200+
at: 1 put: (subTree := CTKeyedTree new at: #a put: 'A'; yourself);
201+
at: 2 put: 'B';
202+
yourself.
203+
copy := original copy.
204+
"Modify the copy and ensure the original is unaffected"
205+
(copy at: 1) at: #a put: 'Modified'.
206+
self assert: (copy atPath: #(1 a)) equals: 'Modified'.
207+
self assert: (original atPath: #(1 a)) equals: 'A'.
208+
self deny: (copy at: 1) == subTree.
209+
]
210+
211+
{ #category : #tests }
212+
CTKeyedTreeTest >> testPutFormattedTextOnLevelIndentString [
213+
"Test formatted text output with a custom indent string."
214+
215+
| stream |
216+
stream := String new writeStream.
217+
tree putFormattedTextOn: stream level: 1 indentString: '>>'.
218+
self
219+
assert: stream contents
220+
equals:
221+
'>>1
222+
>> #three : ''One-Three''
223+
>> #two : ''One-Two''
224+
>>2 : ''Two''
225+
'
226+
]
227+
228+
{ #category : #'tests - removing' }
229+
CTKeyedTreeTest >> testRemovePath [
230+
self should: [ tree removePath: #(4) ] raise: self defaultTestError.
231+
self should: [ tree removePath: #(1 one) ] raise: self defaultTestError.
232+
self assert: (tree removePath: #(1 two)) equals: 'One-Two'.
233+
self assert: (tree atPath: #(1 two) ifAbsent: [ #missing ]) equals: #missing.
234+
self assert: (tree removePath: #(2)) equals: 'Two'.
235+
self assert: (tree atPath: #(2) ifAbsent: [ #missing ]) equals: #missing.
236+
]
237+
238+
{ #category : #'tests - removing' }
239+
CTKeyedTreeTest >> testRemovePathIfAbsent [
240+
self assert: (tree removePath: #(4) ifAbsent: [ #none ]) equals: #none.
241+
self assert: (tree removePath: #(1 2 3 4) ifAbsent: [ #none ]) equals: #none.
242+
self assert: (tree removePath: #(1 two) ifAbsent: [ #none ]) equals: 'One-Two'.
243+
self assert: (tree atPath: #(1 two) ifAbsent: [ #missing ]) equals: #missing.
244+
self assert: (tree removePath: #(2) ifAbsent: [ #none ]) equals: 'Two'.
245+
self assert: (tree atPath: #(2) ifAbsent: [ #missing ]) equals: #missing.
246+
]
247+
248+
{ #category : #tests }
249+
CTKeyedTreeTest >> testSortBlock [
250+
"Test the sort block for keys."
251+
252+
| treeWithMixedKeys sortedKeys |
253+
treeWithMixedKeys := CTKeyedTree new
254+
at: 2 put: 'Two';
255+
at: #a put: 'A';
256+
at: 1 put: 'One';
257+
yourself.
258+
sortedKeys := treeWithMixedKeys keys asSortedCollection: treeWithMixedKeys sortBlock.
259+
self assert: sortedKeys asArray equals: #(#a 1 2)
260+
]
261+
262+
{ #category : #'tests - operation' }
263+
CTKeyedTreeTest >> testSubtrees [
264+
| t1 t2 t3 t4 |
265+
t2 := self t2.
266+
t3 := self t13.
267+
t1 := CTKeyedTree new
268+
at: 1 put: t2;
269+
at: 2 put: '2';
270+
at: 3 put: (t4 := self t13);
271+
yourself.
272+
self assert: t1 subtrees equals: {t2. t4}.
273+
self assert: (t1 at: 1) subtrees equals: {t3}.
274+
]
275+
276+
{ #category : #'tests - operation' }
277+
CTKeyedTreeTest >> testSubtreesEmpty [
278+
| emptyTree |
279+
emptyTree := CTKeyedTree new.
280+
self assert: emptyTree subtrees isEmpty.
281+
]

0 commit comments

Comments
 (0)