Class: TestKyaniteStringNested

Inherits
UnitTest
  • Object
show all
Defined in
test/string/test_nested.rb

Tests for String

String Additions

Kyanite definitions

String

Kyanite tests and examples

Cast Chars Diff Database-Helper Miscellaneous Nested Split

Usage

require 'kyanite/string'

Required from Facets String:

shatter(re)

Breaks a string up into an array based on a regular expression. Similar to scan, but includes the matches.

Instance Method Summary (collapse)

Instance Method Details

- (Object) test_010_anti 



15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'test/string/test_nested.rb', line 15

def test_010_anti
  test = '()[]<>{}'
  test.split(//).each do |t|
    assert_equal t, t.anti.anti
    assert t != t.anti
  end
  assert_equal '</hallo>', '<hallo>'.anti
  assert_equal '<hallo>', '</hallo>'.anti
  assert_equal '*', '*'.anti
  assert_equal '"', '"'.anti
  assert_equal "'", "'".anti
end

- (Object) test_020_index_bracket 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'test/string/test_nested.rb', line 29

def test_020_index_bracket
  test = 'Hallo welt wort'
  assert_equal nil,       test.index_bracket(/['"({<\[]/)
   
  test = 'Hallo(welt)wort'
  assert_equal 5..10,     test.index_bracket(/['"({<\[]/)
  assert_equal 5..10,     test.index_bracket('(')
  assert_equal nil,       test.index_bracket(')')
  assert_equal nil,       test.index_bracket('(',6)
  
  test = 'Hallo"welt"wort'
  assert_equal 5..10,     test.index_bracket(/['"({<\[]/)
  assert_equal 5..10,     test.index_bracket('"')
  assert_equal nil,       test.index_bracket(')')
  assert_equal nil,       test.index_bracket('(',6)    
  
  test = 'Hallo[welt]wort'
  assert_equal 5..10,    test.index_bracket(/['"({<\[]/)
  
  test = '(hallo) [welt] wort'    
  assert_equal 0..6,      test.index_bracket(/['"({<\[]/)
  assert_equal 8..13,     test.index_bracket(/['"({<\[]/, 1 )
  
  test = 'Hallo(welt(klammer)bla(blubb)nuff)wort'
  # see RULER
  # see test
  # see test[test.index_bracket('(',11)]
  assert_equal 5..33,     test.index_bracket(/['"({<\[]/)
  assert_equal 10..18,    test.index_bracket('(',6)    
  assert_equal 22..28,    test.index_bracket('(',11)     
end

- (Object) test_030_mask_ungeklammert 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'test/string/test_nested.rb', line 68

def test_030_mask_ungeklammert
  assert_raise(ArgumentError) {result = test.mask(1,0)   {|s| s.upcase} }     
  assert_raise(ArgumentError) {result = test.mask(nil,1) {|s| s.upcase} }     
  assert_raise(ArgumentError) {result = test.mask(1,nil) {|s| s.upcase} } 
  
  test = 'hallo'
  
  result = test.mask {|s| s.upcase}  
  assert_equal 'hallo', result
  result = test.mask {|s| '-'}  
  assert_equal 'hallo', result    
  result = test.mask {|s| "+#{s}+"}  
  assert_equal 'hallo', result     

  result = test.mask(:level_start => 0) {|s| s.upcase}  
  assert_equal 'HALLO', result
  result = test.mask(:level_start => 0) {|s| '-'}  
  assert_equal '-', result    
  result = test.mask(:level_start => 0) {|s| "+#{s}+"}  
  assert_equal '+hallo+', result   
  
  result = test.mask(:level_start => 0, :level_end => 0) {|s| s.upcase}  
  assert_equal 'HALLO', result
  result = test.mask(:level_start => 0, :level_end => 0) {|s| '-'}  
  assert_equal '-', result    
  result = test.mask(:level_start => 0, :level_end => 0) {|s| "+#{s}+"}  
  assert_equal '+hallo+', result        
end

- (Object) test_040_mask_eine_klammer 



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'test/string/test_nested.rb', line 98

def test_040_mask_eine_klammer 
  test = 'a_level_0(level1)b_level_0'  
  options = {  :pattern      => /\(/   }
  
  result = test.mask(options) {|s| s.upcase}   
  assert_equal 'a_level_0(LEVEL1)b_level_0',          result     
  result = test.mask(options) {|s| '-'}  
  assert_equal 'a_level_0(-)b_level_0',               result  
  result = test.mask(options) {|s| " +#{s}+ "}  
  assert_equal 'a_level_0( +level1+ )b_level_0',      result    
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/                        
                    ) {|s| s.upcase}   
  assert_equal 'A_LEVEL_0(level1)B_LEVEL_0',          result   
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/    
                     ) {|s| '-'}   
  assert_equal '-(level1)-', result  
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/    
                    ) {|s| " +#{s}+ "}       
  assert_equal ' +a_level_0+ (level1) +b_level_0+ ',  result        
end

- (Object) test_050_mask_zwei_klammern 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'test/string/test_nested.rb', line 129

def test_050_mask_zwei_klammern 
  test = 'r_level_0<a_level_1>s_level_0<b_level_1>t_level_0'  
  
  result = test.mask {|s| s.upcase}   
  assert_equal 'r_level_0<A_LEVEL_1>s_level_0<B_LEVEL_1>t_level_0',             result     
  result = test.mask {|s| '-'}  
  assert_equal 'r_level_0<->s_level_0<->t_level_0',                             result   
  result = test.mask {|s| " +#{s}+ "}  
  assert_equal 'r_level_0< +a_level_1+ >s_level_0< +b_level_1+ >t_level_0',     result     
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| s.upcase}   
  assert_equal 'R_LEVEL_0<a_level_1>S_LEVEL_0<b_level_1>T_LEVEL_0',             result 
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| '-'}  
  assert_equal '-<a_level_1>-<b_level_1>-',                                     result  
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| " +#{s}+ "} 
  assert_equal ' +r_level_0+ <a_level_1> +s_level_0+ <b_level_1> +t_level_0+ ', result        
end

- (Object) test_060_mask_leer 



153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'test/string/test_nested.rb', line 153

def test_060_mask_leer 
  test = ''  
  
  result = test.mask {|s| s.upcase}  
  assert_equal '', result
  result = test.mask {|s| nil }  
  assert_equal '', result    
  result = test.mask {|s| '-'}  
  assert_equal '', result       
  result = test.mask {|s| s + '+'}  
  assert_equal '', result    
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| s.upcase}   
  assert_equal '', result
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| nil}   
  assert_equal '', result    
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| '-'}  
  assert_equal '-', result     
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :skip_empty   => true) {|s| '-'}  
  assert_equal '', result        
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0 ) {|s| s + '+'}  
  assert_equal '+', result   

  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :skip_empty   => true) {|s| s + '+'}   
  assert_equal '', result        
end

- (Object) test_070_mask_start_mit_level_1 



193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'test/string/test_nested.rb', line 193

def test_070_mask_start_mit_level_1
  options = {  :pattern      => /\(/   }  
  test = '(level1)level0'  
  
  result = test.mask(options) {|s| s.upcase}   
  assert_equal '(LEVEL1)level0',            result     
  result = test.mask(options) {|s| '-'}  
  assert_equal '(-)level0',                 result  
  result = test.mask(options) {|s| "+#{s}+"}  
  assert_equal '(+level1+)level0',          result    
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/    
                    ) {|s| s.upcase}   
  assert_equal '(level1)LEVEL0',            result 
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/    
                    ) {|s| '-'} 
  assert_equal '-(level1)-',                result  
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/,                            
                      :skip_empty   => true) {|s| '-'}  
  assert_equal '(level1)-', result        
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/
                    ) {|s| "+#{s}+"} 
  assert_equal '++(level1)+level0+',          result  

  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/,                           
                      :skip_empty   => true) {|s| "+#{s}+"}   
  assert_equal '(level1)+level0+', result      
end

- (Object) test_080_mask_end_mit_level_1 



236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'test/string/test_nested.rb', line 236

def test_080_mask_end_mit_level_1
  test = 'level0(level1)'  
  options = {  :pattern      => /\(/   }      
  
  result = test.mask(options) {|s| s.upcase}   
  assert_equal 'level0(LEVEL1)',            result     
  result = test.mask(options) {|s| '-'}  
  assert_equal 'level0(-)',                 result  
  result = test.mask(options) {|s| "+#{s}+"}  
  assert_equal 'level0(+level1+)',          result    
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,                        
                      :pattern      => /\(/  
                    ) {|s| s.upcase}  
  assert_equal 'LEVEL0(level1)',            result    
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,                       
                      :pattern      => /\(/
                    ) {|s| '-'} 
  assert_equal '-(level1)-',                result  
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/,                         
                      :skip_empty   => true) {|s| '-'}  
  assert_equal '-(level1)', result       
  
  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/
                    ) {|s| "+#{s}+"} 
  assert_equal '+level0+(level1)++',          result     

  result = test.mask( :level_start  => 0,
                      :level_end    => 0,
                      :pattern      => /\(/,                         
                      :skip_empty   => true) {|s| "+#{s}+"}  
  assert_equal '+level0+(level1)', result 
end

- (Object) test_090_mask_multilevel 



280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
 
# File 'test/string/test_nested.rb', line 280

def test_090_mask_multilevel
  test    = '((((()))))'
  options = {  :pattern      => /\(/   } 
  
  result = test.mask(options) {|s| "+#{s}+"}  
  assert_equal '(++(++(++(++(++)++)++)++)++)',          result    
  
  result = test.mask( :level_start  => 0,
                      :skip_empty   => false,
                      :pattern      => /\(/  
                    ) {|s| "+#{s}+"}    
  assert_equal '++(++(++(++(++(++)++)++)++)++)++',          result     

  result = test.mask( :level_start  => 0,
                      :pattern      => /\(/,      
                      :skip_empty   => true) {|s| "+#{s}+"}    
  assert_equal test,          result    

  result = test.mask( :level_start  => 2,
                      :level_end    => 4,
                      :pattern      => /\(/  
                    ) {|s| "+#{s}+"}    
  assert_equal '((++(++(++()++)++)++))',          result     
end

- (Object) test_100_mask_with_brackets 



306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
 
# File 'test/string/test_nested.rb', line 306

def test_100_mask_with_brackets
  test = 'level0(lev(el)1)level0'  
  options = {:with_brackets => true}
  
  result = test.mask( :with_brackets  => true,
                      :level_start    => 0,
                      :level_end      => 0,
                      :pattern        => /\(/  
                      ) {|s| s.tr('()','{}')}   
  assert_equal 'level0{lev(el)1}level0'  ,          result     
  
  result = test.mask( :with_brackets  => true,
                      :level_start    => 1,
                      :level_end      => 1,
                      :pattern        => /\(/  
                      ) {|s| s.tr('()','<>')}   
  assert_equal 'level0(lev<el>1)level0'  ,          result       
  
   
end