Skip to content

Commit e09755a

Browse files
pankaj-bindpankaj-bind
committed
class names and code fixed as per conventions
1 parent 270aa73 commit e09755a

6 files changed

Lines changed: 433 additions & 444 deletions

File tree

‎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: 273 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,273 @@
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 - at' }
93+
CTKeyedTreeTest >> testAtPathIfAbsent [
94+
self assert: (tree atPath: #(1) ifAbsent: [ #missing ]) equals: firstLevelOneSubTree.
95+
self assert: (tree atPath: #(1 two) ifAbsent: [ #missing ]) equals: 'One-Two'.
96+
self assert: (tree atPath: #(1 three) ifAbsent: [ #missing ]) equals: 'One-Three'.
97+
self assert: (tree atPath: #(2) ifAbsent: [ #missing ]) equals: 'Two'.
98+
self assert: (tree atPath: #(2 4) ifAbsent: [ #missing ]) equals: #missing.
99+
self assert: (tree atPath: #(1 two three) ifAbsent: [ #missing ]) equals: #missing.
100+
self assert: (tree atPath: #(3) ifAbsent: [ #missing ]) equals: #missing.
101+
]
102+
103+
{ #category : #'tests - at' }
104+
CTKeyedTreeTest >> testAtPathIfAbsentPut [
105+
self assert: (tree atPath: #(1) ifAbsentPut: [ #new ]) equals: firstLevelOneSubTree.
106+
self assert: (tree atPath: #(1 two) ifAbsentPut: [ #new ]) equals: 'One-Two'.
107+
self assert: (tree atPath: #(1 three) ifAbsentPut: [ #new ]) equals: 'One-Three'.
108+
self assert: (tree atPath: #(2) ifAbsentPut: [ #new ]) equals: 'Two'.
109+
self assert: (tree atPath: #(1 four one) ifAbsentPut: [ #anotherNew ]) equals: #anotherNew.
110+
self assert: (tree atPath: #(1 four one)) equals: #anotherNew.
111+
self assert: (tree atPath: #(3) ifAbsentPut: [ #yetAnotherNew ]) equals: #yetAnotherNew.
112+
self assert: (tree atPath: #(3)) equals: #yetAnotherNew.
113+
self should: [ tree atPath: #(2 4) ifAbsentPut: [ #new ] ] raise: self defaultTestError.
114+
]
115+
116+
{ #category : #'tests - at' }
117+
CTKeyedTreeTest >> testAtPathPut [
118+
self assert: (tree atPath: #(1 two) put: #new) equals: #new.
119+
self assert: (tree atPath: #(1 two)) equals: #new.
120+
self assert: (tree atPath: #(1 three) put: (firstLevelOneSubTree := CTKeyedTree new)) equals: firstLevelOneSubTree.
121+
self assert: (tree atPath: #(1 three $1) put: #anotherNew) equals: #anotherNew.
122+
self assert: (tree atPath: #(1 three $1)) equals: #anotherNew.
123+
self assert: (tree atPath: #(1 four one) put: #anotherNew) equals: #anotherNew.
124+
self assert: (tree atPath: #(1 four one)) equals: #anotherNew.
125+
self should: [ tree atPath: #(2 4) put: [ #new ] ] raise: self defaultTestError.
126+
]
127+
128+
{ #category : #'tests - copying' }
129+
CTKeyedTreeTest >> testCopy [
130+
| c t2 t3 |
131+
tree := CTKeyedTree new
132+
at: 1 put: (t2 := CTKeyedTree new
133+
at: #two put: 'One-Two';
134+
at: #three put: 'One-Three';
135+
at: #four put: (t3 := CTKeyedTree new);
136+
yourself);
137+
at: 2 put: 'Two';
138+
yourself.
139+
c := tree copy.
140+
self assert: c = tree.
141+
self deny: c == tree.
142+
self assert: (c at: 1) = t2.
143+
self deny: (c at: 1) == t2.
144+
self assert: (c atPath: #(1 four)) = t3.
145+
self deny: (c atPath: #(1 four)) == t3.
146+
]
147+
148+
{ #category : #'tests - operation' }
149+
CTKeyedTreeTest >> testFormattedText [
150+
self assert: self t13 formattedText equals:
151+
'1 : ''1-3-1''
152+
2 : ''1-3-2''
153+
'.
154+
self assert: self t2AB formattedText equals:
155+
'1 : ''1-1''
156+
2 : ''1-2''
157+
3
158+
#A : ''1-3-1''
159+
#B : ''1-3-2''
160+
'.
161+
]
162+
163+
{ #category : #'tests - operation' }
164+
CTKeyedTreeTest >> testMerge [
165+
| t1 t2 t13 m subT1 subt11 wrapSubt11 |
166+
t13 := self t13.
167+
subT1 := self t2.
168+
subt11 := CTKeyedTree new
169+
at: 1 put: '1-1-1';
170+
at: 2 put: '1-1-2';
171+
yourself.
172+
wrapSubt11 := CTKeyedTree new
173+
at: 1 put: subt11;
174+
at: 2 put: '1-2*';
175+
yourself.
176+
t1 := CTKeyedTree new
177+
at: 1 put: subT1;
178+
at: 2 put: '2';
179+
yourself.
180+
t2 := CTKeyedTree new
181+
at: 1 put: wrapSubt11;
182+
at: 3 put: '3';
183+
yourself.
184+
m := t1 merge: t2.
185+
self assert: (m at: 2) equals: '2'.
186+
self assert: (m at: 3) equals: '3'.
187+
self assert: (m atPath: #(1 2)) equals: '1-2*'.
188+
self assert: (m atPath: #(1 1 1)) equals: '1-1-1'.
189+
self assert: (m atPath: #(1 1 2)) equals: '1-1-2'.
190+
self assert: (m atPath: #(1 3 1)) equals: '1-3-1'.
191+
self assert: (m atPath: #(1 3 2)) equals: '1-3-2'.
192+
]
193+
194+
{ #category : #'tests - copying' }
195+
CTKeyedTreeTest >> testPostCopy [
196+
| original copy subTree |
197+
original := CTKeyedTree new
198+
at: 1 put: (subTree := CTKeyedTree new at: #a put: 'A'; yourself);
199+
at: 2 put: 'B';
200+
yourself.
201+
copy := original copy.
202+
"Modify the copy and ensure the original is unaffected"
203+
(copy at: 1) at: #a put: 'Modified'.
204+
self assert: (copy atPath: #(1 a)) equals: 'Modified'.
205+
self assert: (original atPath: #(1 a)) equals: 'A'.
206+
self deny: (copy at: 1) == subTree.
207+
]
208+
209+
{ #category : #'tests - printing' }
210+
CTKeyedTreeTest >> testPutFormattedTextOnLevelIndentString [
211+
| stream |
212+
stream := String new writeStream.
213+
tree putFormattedTextOn: stream level: 1 indentString: '>>'.
214+
self assert: stream contents equals:
215+
'>>1
216+
>> #three : ''One-Three''
217+
>> #two : ''One-Two''
218+
>>2 : ''Two''
219+
'.
220+
]
221+
222+
{ #category : #'tests - removing' }
223+
CTKeyedTreeTest >> testRemovePath [
224+
self should: [ tree removePath: #(4) ] raise: self defaultTestError.
225+
self should: [ tree removePath: #(1 one) ] raise: self defaultTestError.
226+
self assert: (tree removePath: #(1 two)) equals: 'One-Two'.
227+
self assert: (tree atPath: #(1 two) ifAbsent: [ #missing ]) equals: #missing.
228+
self assert: (tree removePath: #(2)) equals: 'Two'.
229+
self assert: (tree atPath: #(2) ifAbsent: [ #missing ]) equals: #missing.
230+
]
231+
232+
{ #category : #'tests - removing' }
233+
CTKeyedTreeTest >> testRemovePathIfAbsent [
234+
self assert: (tree removePath: #(4) ifAbsent: [ #none ]) equals: #none.
235+
self assert: (tree removePath: #(1 2 3 4) ifAbsent: [ #none ]) equals: #none.
236+
self assert: (tree removePath: #(1 two) ifAbsent: [ #none ]) equals: 'One-Two'.
237+
self assert: (tree atPath: #(1 two) ifAbsent: [ #missing ]) equals: #missing.
238+
self assert: (tree removePath: #(2) ifAbsent: [ #none ]) equals: 'Two'.
239+
self assert: (tree atPath: #(2) ifAbsent: [ #missing ]) equals: #missing.
240+
]
241+
242+
{ #category : #'tests - operation' }
243+
CTKeyedTreeTest >> testSortBlock [
244+
| treeWithMixedKeys sortedKeys |
245+
treeWithMixedKeys := CTKeyedTree new
246+
at: 2 put: 'Two';
247+
at: #a put: 'A';
248+
at: 1 put: 'One';
249+
yourself.
250+
sortedKeys := treeWithMixedKeys keys asSortedCollection: treeWithMixedKeys sortBlock.
251+
self assert: sortedKeys asArray equals: #(1 2 #a).
252+
]
253+
254+
{ #category : #'tests - operation' }
255+
CTKeyedTreeTest >> testSubtrees [
256+
| t1 t2 t3 t4 |
257+
t2 := self t2.
258+
t3 := self t13.
259+
t1 := CTKeyedTree new
260+
at: 1 put: t2;
261+
at: 2 put: '2';
262+
at: 3 put: (t4 := self t13);
263+
yourself.
264+
self assert: t1 subtrees equals: {t2. t4}.
265+
self assert: (t1 at: 1) subtrees equals: {t3}.
266+
]
267+
268+
{ #category : #'tests - operation' }
269+
CTKeyedTreeTest >> testSubtreesEmpty [
270+
| emptyTree |
271+
emptyTree := CTKeyedTree new.
272+
self assert: emptyTree subtrees isEmpty.
273+
]

0 commit comments

Comments
 (0)