← Back to branch summary

~sharpie/geos/3.3.2

« back to all changes in this revision

Viewing changes to swig/ruby/test/test_relations.rb

  • Committer: Bazaar Package Importer
  • Author(s): Fabio Tranchitella
  • Date: 2006-11-06 21:35:52 UTC
  • mfrom: (3.1.3 feisty)
  • Revision ID: james.westby@ubuntu.com-20061106213552-m03o92ggj1na737b
Tags: 2.2.3-3
debian/control: move doxygen from build-depends-indep to build-depends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
swig/ruby/test/test_relations.rb
 
1
#!/usr/bin/env ruby
 
2
 
 
3
# These tests evaluate the geos relational operators
 
4
 
 
5
 
 
6
require 'test/unit'
 
7
require 'geos'
 
8
require 'test_helper'
 
9
 
 
10
class TestGeosRelations < Test::Unit::TestCase
 
11
  X = Geos::IllegalArgumentException
 
12
  
 
13
  def setup
 
14
    @test_helper = GeosTestHelper.new()
 
15
  end
 
16
 
 
17
  def get_expected_result(results, row, column)
 
18
    value = results[row][column]
 
19
 
 
20
    # 0 is false and 1 is true
 
21
    case
 
22
      when value == 0
 
23
        return false
 
24
      when value == 1
 
25
        return true
 
26
      when value == X
 
27
        return X
 
28
      else
 
29
        raise ArgumentError, "Unknown result value"
 
30
    end
 
31
  end
 
32
  
 
33
  def run_relational_operation(operation, results, &block)
 
34
    STDOUT << "\n" << "------ #{operation} RELATION  ------" << "\n"
 
35
    STDOUT.flush()  
 
36
 
 
37
    # Create the geometries
 
38
    geoms = @test_helper.create_geoms()
 
39
 
 
40
    # Loop through the the geometries the first time
 
41
    row = 0
 
42
    geoms.each do |geom1|
 
43
      # Loop through the the geometries the second time
 
44
      column = 0
 
45
      geoms.each do |geom2|
 
46
        # Get the expected result
 
47
        expected = self.get_expected_result(results, row, column)
 
48
 
 
49
        begin
 
50
          # Get the actual result from the provided block
 
51
          result = yield(geom1, geom2)
 
52
 
 
53
          if result
 
54
            STDOUT << "1\t"
 
55
          else
 
56
            STDOUT << "0\t"
 
57
          end
 
58
 
 
59
          # Did this work?
 
60
          assert_equal(expected, result, "#{operation} failure")
 
61
 
 
62
        # Geometry Collection is not a valid argument
 
63
        rescue Geos::IllegalArgumentException => error
 
64
          # This is probably ok but check
 
65
          assert_equal(expected, Geos::IllegalArgumentException)
 
66
          STDOUT << "X\t"
 
67
        end
 
68
        STDOUT.flush()
 
69
        column += 1
 
70
      end
 
71
      STDOUT << "\n"
 
72
      STDOUT.flush()
 
73
      row += 1
 
74
    end
 
75
  end
 
76
 
 
77
  def test_contains()
 
78
    # Setup the expected results
 
79
 
 
80
    # CONTAINS Results
 
81
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
82
    results = Array.new()
 
83
    results[0] =  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
84
    results[1] =  [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
85
    results[2] =  [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
 
86
    results[3] =  [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
 
87
    results[4] =  [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
 
88
    results[5] =  [X, X, X, X, X, X, 0, 0, 0, 0, X]
 
89
    results[6] =  [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
 
90
    results[7] =  [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
 
91
    results[8] =  [0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0]
 
92
    results[9] =  [0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0]
 
93
    results[10] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 
94
    
 
95
    self.run_relational_operation("CONTAINS", results) do |geom1, geom2|
 
96
      geom1.contains(geom2)
 
97
    end
 
98
  end
 
99
  
 
100
  def test_crosses()
 
101
    # Setup the expected results
 
102
 
 
103
    # CROSSES Results
 
104
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
105
    results = Array.new()
 
106
    results[0] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
107
    results[1] =  [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
108
    results[2] =  [0, 1, 0, 0, 0, X, 1, 1, 1, 1, 0]
 
109
    results[3] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
110
    results[4] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
111
    results[5] =  [X, X, X, X, X, X, X, X, X, X, X]
 
112
    results[6] =  [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
113
    results[7] =  [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
114
    results[8] =  [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
115
    results[9] =  [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
116
    results[10] = [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
117
    
 
118
    self.run_relational_operation("CROSSES", results) do |geom1, geom2|
 
119
      geom1.crosses(geom2)
 
120
    end
 
121
  end
 
122
  
 
123
  def test_disjoint()
 
124
    # Setup the expected results
 
125
 
 
126
    # DISJOINT Results
 
127
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
128
    results = Array.new()
 
129
    results[0] =  [0, 1, 1, 1, 0, X, 1, 1, 1, 1, 1]
 
130
    results[1] =  [1, 0, 0, 1, 1, X, 1, 1, 1, 1, 1]
 
131
    results[2] =  [1, 0, 0, 1, 1, X, 0, 0, 0, 0, 0]
 
132
    results[3] =  [1, 1, 1, 0, 0, X, 1, 1, 1, 1, 1]
 
133
    results[4] =  [0, 1, 1, 0, 0, X, 1, 1, 1, 1, 1]
 
134
    results[5] =  [X, X, X, X, X, X, X, X, X, X, X]
 
135
    results[6] =  [1, 1, 0, 1, 1, X, 0, 0, 0, 0, 1]
 
136
    results[7] =  [1, 1, 0, 1, 1, X, 0, 0, 0, 0, 1]
 
137
    results[8] =  [1, 1, 0, 1, 1, X, 0, 0, 0, 0, 1]
 
138
    results[9] =  [1, 1, 0, 1, 1, X, 0, 0, 0, 0, 1]
 
139
    results[10] = [1, 1, 0, 1, 1, X, 1, 1, 1, 1, 0]
 
140
    
 
141
    self.run_relational_operation("DISJOINT", results) do |geom1, geom2|
 
142
      geom1.disjoint(geom2)
 
143
    end
 
144
  end
 
145
 
 
146
  def test_equals()
 
147
    # Setup the expected results
 
148
 
 
149
    # EQUALS Results
 
150
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
151
    results = Array.new()
 
152
    results[0] =  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
153
    results[1] =  [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
154
    results[2] =  [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
 
155
    results[3] =  [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
 
156
    results[4] =  [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
 
157
    results[5] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
158
    results[6] =  [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
 
159
    results[7] =  [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
 
160
    results[8] =  [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
 
161
    results[9] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 
162
    results[10] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 
163
    
 
164
    self.run_relational_operation("EQUALS", results) do |geom1, geom2|
 
165
      geom1.equals(geom2)
 
166
    end
 
167
  end
 
168
 
 
169
  def test_equals_exact()
 
170
    # Setup the expected results
 
171
 
 
172
    # EQUALS_EXACT Results
 
173
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
174
    results = Array.new()
 
175
    results[0] =  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
176
    results[1] =  [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
177
    results[2] =  [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
 
178
    results[3] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
179
    results[4] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
180
    results[5] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
181
    results[6] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
182
    results[7] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
183
    results[8] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
184
    results[9] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
 
185
    results[10] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 
186
    
 
187
    self.run_relational_operation("EQUALS_EXACT", results) do |geom1, geom2|
 
188
      geom1.equals_exact(geom2)
 
189
    end
 
190
  end
 
191
  
 
192
  def test_intersects()
 
193
    # Setup the expected results
 
194
 
 
195
    # INTERSECTS Results
 
196
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
197
    results = Array.new()
 
198
    results[0] =  [1, 0, 0, 0, 1, X, 0, 0, 0, 0, 0]
 
199
    results[1] =  [0, 1, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
200
    results[2] =  [0, 1, 1, 0, 0, X, 1, 1, 1, 1, 1]
 
201
    results[3] =  [0, 0, 0, 1, 1, X, 0, 0, 0, 0, 0]
 
202
    results[4] =  [1, 0, 0, 1, 1, X, 0, 0, 0, 0, 0]
 
203
    results[5] =  [X, X, X, X, X, X, X, X, X, X, X]
 
204
    results[6] =  [0, 0, 1, 0, 0, X, 1, 1, 1, 1, 0]
 
205
    results[7] =  [0, 0, 1, 0, 0, X, 1, 1, 1, 1, 0]
 
206
    results[8] =  [0, 0, 1, 0, 0, X, 1, 1, 1, 1, 0]
 
207
    results[9] =  [0, 0, 1, 0, 0, X, 1, 1, 1, 1, 0]
 
208
    results[10] = [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 1]
 
209
    
 
210
    self.run_relational_operation("INTERSECTS", results) do |geom1, geom2|
 
211
      geom1.intersects(geom2)
 
212
    end
 
213
  end
 
214
 
 
215
  def test_is_within_distance()
 
216
    # Setup the expected results
 
217
 
 
218
    # IS_WITHIN_DISTANCE Results
 
219
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
220
    results = Array.new()
 
221
    results[0] =  [1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0]
 
222
    results[1] =  [0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0]
 
223
    results[2] =  [0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0]
 
224
    results[3] =  [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0]
 
225
    results[4] =  [1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0]
 
226
    results[5] =  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]
 
227
    results[6] =  [0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0]
 
228
    results[7] =  [0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0]
 
229
    results[8] =  [0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0]
 
230
    results[9] =  [0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0]
 
231
    results[10] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
 
232
    
 
233
    self.run_relational_operation("IS_WITHIN_DISTANCE", results) do |geom1, geom2|
 
234
      geom1.is_within_distance(geom2, 2)
 
235
    end
 
236
  end
 
237
  
 
238
  def test_overlaps()
 
239
    # Setup the expected results
 
240
 
 
241
    # OVERLAPS Results
 
242
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
243
    results = Array.new()
 
244
    results[0] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
245
    results[1] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
246
    results[2] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 1]
 
247
    results[3] =  [0, 0, 0, 0, 1, X, 0, 0, 0, 0, 0]
 
248
    results[4] =  [0, 0, 0, 1, 0, X, 0, 0, 0, 0, 0]
 
249
    results[5] =  [X, X, X, X, X, X, X, X, X, X, X]
 
250
    results[6] =  [0, 0, 0, 0, 0, X, 0, 1, 0, 0, 0]
 
251
    results[7] =  [0, 0, 0, 0, 0, X, 1, 0, 1, 1, 0]
 
252
    results[8] =  [0, 0, 0, 0, 0, X, 0, 1, 0, 0, 0]
 
253
    results[9] =  [0, 0, 0, 0, 0, X, 0, 1, 0, 0, 0]
 
254
    results[10] = [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
255
    
 
256
    self.run_relational_operation("OVERLAPS", results) do |geom1, geom2|
 
257
      geom1.overlaps(geom2)
 
258
    end
 
259
  end
 
260
 
 
261
  def test_relate()
 
262
    # Setup the expected results
 
263
 
 
264
    # RELATE Results
 
265
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
266
    results = Array.new()
 
267
    results[0] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
268
    results[1] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
269
    results[2] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
270
    results[3] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
271
    results[4] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
272
    results[5] =  [X, X, X, X, X, X, X, X, X, X, X]
 
273
    results[6] =  [0, 0, 0, 0, 0, X, 0, 1, 0, 0, 0]
 
274
    results[7] =  [0, 0, 0, 0, 0, X, 1, 0, 1, 1, 0]
 
275
    results[8] =  [0, 0, 0, 0, 0, X, 0, 1, 0, 0, 0]
 
276
    results[9] =  [0, 0, 0, 0, 0, X, 0, 1, 0, 0, 0]
 
277
    results[10] = [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
278
    
 
279
    self.run_relational_operation("RELATE", results) do |geom1, geom2|
 
280
      geom1.relate(geom2, "212101212")
 
281
    end
 
282
  end
 
283
 
 
284
  def test_touches()
 
285
    # Setup the expected results
 
286
 
 
287
    # TOUCHES Results
 
288
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
289
    results = Array.new()
 
290
    results[0] =  [0, 0, 0, 0, 1, X, 0, 0, 0, 0, 0]
 
291
    results[1] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
292
    results[2] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
293
    results[3] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
294
    results[4] =  [1, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
295
    results[5] =  [X, X, X, X, X, X, X, X, X, X, X]
 
296
    results[6] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
297
    results[7] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
298
    results[8] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
299
    results[9] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
300
    results[10] = [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
301
    
 
302
    self.run_relational_operation("TOUCHES", results) do |geom1, geom2|
 
303
      geom1.touches(geom2)
 
304
    end
 
305
  end
 
306
 
 
307
  def test_within()
 
308
    # Setup the expected results
 
309
 
 
310
    # WITHIN Results
 
311
    #             [0][1][2][3][4][5][6][7][8][9][10]
 
312
    results = Array.new()
 
313
    results[0] =  [1, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
314
    results[1] =  [0, 1, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
315
    results[2] =  [0, 0, 1, 0, 0, X, 0, 0, 0, 0, 0]
 
316
    results[3] =  [0, 0, 0, 1, 0, X, 0, 0, 0, 0, 0]
 
317
    results[4] =  [0, 0, 0, 0, 1, X, 0, 0, 0, 0, 0]
 
318
    results[5] =  [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 0]
 
319
    results[6] =  [0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0]
 
320
    results[7] =  [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
 
321
    results[8] =  [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0]
 
322
    results[9] =  [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
 
323
    results[10] = [0, 0, 0, 0, 0, X, 0, 0, 0, 0, 1]
 
324
    
 
325
    self.run_relational_operation("WITHIN", results) do |geom1, geom2|
 
326
      geom1.within(geom2)
 
327
    end
 
328
  end
 
329
end
 
 
b'\\ No newline at end of file'