BitStructEx 0.0.64 → 0.0.65
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- metadata +1 -9
- data/Rakefile +0 -55
- data/Version +0 -1
- data/lib/ruby/rake/version.rb +0 -71
- data/test/ruby/bit_struct/test_bit_slicer.rb +0 -299
- data/test/ruby/bit_struct/test_struct_base.rb +0 -127
- data/test/ruby/bit_struct/test_text.rb +0 -54
- data/test/ruby/bit_struct/test_text_struct.rb +0 -58
- data/test/ruby/runner.rb +0 -127
metadata
CHANGED
|
@@ -3,7 +3,7 @@ rubygems_version: 0.8.11
|
|
|
3
3
|
specification_version: 1
|
|
4
4
|
name: BitStructEx
|
|
5
5
|
version: !ruby/object:Gem::Version
|
|
6
|
-
version: 0.0.
|
|
6
|
+
version: 0.0.65
|
|
7
7
|
date: 2006-04-13 00:00:00 +02:00
|
|
8
8
|
summary: Simple DSL for defining bit-based structures on byte data.
|
|
9
9
|
require_paths:
|
|
@@ -28,20 +28,12 @@ cert_chain:
|
|
|
28
28
|
authors:
|
|
29
29
|
- The.French.DJ
|
|
30
30
|
files:
|
|
31
|
-
- lib/ruby/rake/version.rb
|
|
32
31
|
- src/ruby/bit_struct/bit_slicer.rb
|
|
33
32
|
- src/ruby/bit_struct/field.rb
|
|
34
33
|
- src/ruby/bit_struct/nested.rb
|
|
35
34
|
- src/ruby/bit_struct/struct_base.rb
|
|
36
35
|
- src/ruby/bit_struct/text.rb
|
|
37
36
|
- src/ruby/bit_struct/unsigned.rb
|
|
38
|
-
- test/ruby/runner.rb
|
|
39
|
-
- test/ruby/bit_struct/test_bit_slicer.rb
|
|
40
|
-
- test/ruby/bit_struct/test_struct_base.rb
|
|
41
|
-
- test/ruby/bit_struct/test_text.rb
|
|
42
|
-
- test/ruby/bit_struct/test_text_struct.rb
|
|
43
|
-
- Rakefile
|
|
44
|
-
- Version
|
|
45
37
|
test_files: []
|
|
46
38
|
|
|
47
39
|
rdoc_options: []
|
data/Rakefile
DELETED
|
@@ -1,55 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
require 'rake/clean'
|
|
3
|
-
require 'rake/gempackagetask'
|
|
4
|
-
require 'rake/version'
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
PROJECT_NAME='BitStructEx'
|
|
8
|
-
PROJECT_FORGE_ID='bit-struct-ex'
|
|
9
|
-
|
|
10
|
-
SRC_DIR='src/ruby'
|
|
11
|
-
TEST_DIR='test/ruby'
|
|
12
|
-
|
|
13
|
-
PKG_VERSION = Rake::Version.new
|
|
14
|
-
PKG_FILES = FileList[
|
|
15
|
-
'lib/**/*.rb',
|
|
16
|
-
'src/**/*.rb',
|
|
17
|
-
'test/**/*.rb',
|
|
18
|
-
'Rakefile',
|
|
19
|
-
'Version'
|
|
20
|
-
]
|
|
21
|
-
|
|
22
|
-
CLOBBER.include 'pkg'
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
desc "Run all tests, update build number and build gem"
|
|
26
|
-
task :default => [ :run_tests, :increment_build_number, :build_gem ]
|
|
27
|
-
|
|
28
|
-
desc "Execute the unit tests using the specialized test runner"
|
|
29
|
-
task :run_tests do
|
|
30
|
-
sh "ruby -I#{TEST_DIR} #{TEST_DIR}/runner.rb --verbose=v"
|
|
31
|
-
end
|
|
32
|
-
|
|
33
|
-
desc "Increment the build number and upate the Version file"
|
|
34
|
-
task :increment_build_number => [ :run_tests ] do
|
|
35
|
-
src = Dir.glob "#{SRC_DIR}/**/*"
|
|
36
|
-
test = Dir.glob "#{TEST_DIR}/**/*"
|
|
37
|
-
files = src + test
|
|
38
|
-
target = 'Version'
|
|
39
|
-
unless uptodate?( target, files )
|
|
40
|
-
new_version = PKG_VERSION.increment( :build )
|
|
41
|
-
puts "Version: #{new_version}"
|
|
42
|
-
end
|
|
43
|
-
end
|
|
44
|
-
|
|
45
|
-
desc "Build the gem package"
|
|
46
|
-
task :build_gem => [ :run_tests, :define_gem, :gem ]
|
|
47
|
-
|
|
48
|
-
desc "Define the Gem specification and associated task(s)"
|
|
49
|
-
task :define_gem do
|
|
50
|
-
PKG_SPEC = eval IO.read( 'GemSpec' ), binding
|
|
51
|
-
Rake::GemPackageTask.new( PKG_SPEC ) do |pkg|
|
|
52
|
-
pkg.need_zip = true
|
|
53
|
-
pkg.need_tar = true
|
|
54
|
-
end
|
|
55
|
-
end
|
data/Version
DELETED
|
@@ -1 +0,0 @@
|
|
|
1
|
-
0.0.64
|
data/lib/ruby/rake/version.rb
DELETED
|
@@ -1,71 +0,0 @@
|
|
|
1
|
-
module Rake
|
|
2
|
-
|
|
3
|
-
#
|
|
4
|
-
# Simple helper class for maintaining a Version number within a Rakefile.
|
|
5
|
-
# Provides an easy way increase the version tags. Supports purely numeric
|
|
6
|
-
# version tags only.
|
|
7
|
-
#
|
|
8
|
-
class Version
|
|
9
|
-
|
|
10
|
-
def self.increment( symbol )
|
|
11
|
-
Version.new.increment symbol
|
|
12
|
-
end
|
|
13
|
-
|
|
14
|
-
def initialize( config = {} )
|
|
15
|
-
@config = config
|
|
16
|
-
@config[ :version_file ] ||= 'Version'
|
|
17
|
-
@config[ :version_regex ] ||= /\A(\d+)\.(\d+).(\d+)\Z/
|
|
18
|
-
@config[ :version_tags ] ||= [ :release, :version, :build ]
|
|
19
|
-
@tag_values = {}
|
|
20
|
-
read
|
|
21
|
-
end
|
|
22
|
-
|
|
23
|
-
def increment( symbol )
|
|
24
|
-
raise "Unknown tag: #{symbol}" unless version_tags.include? symbol
|
|
25
|
-
read
|
|
26
|
-
@tag_values[ symbol ] += 1
|
|
27
|
-
write
|
|
28
|
-
current_version
|
|
29
|
-
end
|
|
30
|
-
|
|
31
|
-
def current_version
|
|
32
|
-
version_tags.map { |tag| @tag_values[ tag ] }.join( '.' )
|
|
33
|
-
end
|
|
34
|
-
|
|
35
|
-
alias version current_version
|
|
36
|
-
|
|
37
|
-
alias to_s version
|
|
38
|
-
|
|
39
|
-
private
|
|
40
|
-
|
|
41
|
-
def read
|
|
42
|
-
version = IO.read version_file
|
|
43
|
-
raise "Error reading #{version_file}" unless version_regex =~ version
|
|
44
|
-
version_tags.each_index do |idx|
|
|
45
|
-
@tag_values[ version_tags[ idx ] ] = Regexp.last_match[ 1 + idx ].to_i
|
|
46
|
-
end
|
|
47
|
-
self
|
|
48
|
-
end
|
|
49
|
-
|
|
50
|
-
def write
|
|
51
|
-
File.open( version_file, 'w' ) do |file|
|
|
52
|
-
file.write current_version
|
|
53
|
-
end
|
|
54
|
-
self
|
|
55
|
-
end
|
|
56
|
-
|
|
57
|
-
def version_file
|
|
58
|
-
@config[ :version_file ]
|
|
59
|
-
end
|
|
60
|
-
|
|
61
|
-
def version_regex
|
|
62
|
-
@config[ :version_regex ]
|
|
63
|
-
end
|
|
64
|
-
|
|
65
|
-
def version_tags
|
|
66
|
-
@config[ :version_tags ]
|
|
67
|
-
end
|
|
68
|
-
|
|
69
|
-
end
|
|
70
|
-
|
|
71
|
-
end
|
|
@@ -1,299 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
require 'test/unit'
|
|
3
|
-
|
|
4
|
-
require 'bit_struct/bit_slicer'
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
class TestBitSlicer < Test::Unit::TestCase
|
|
9
|
-
|
|
10
|
-
def test_endianess
|
|
11
|
-
slicer = BitStruct::BitSlicer.new 0, 16, BitStruct::BitSlicer::MOTOROLA
|
|
12
|
-
slicer.data = test_data
|
|
13
|
-
assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.data.hexify
|
|
14
|
-
end
|
|
15
|
-
|
|
16
|
-
def test_right_shifted
|
|
17
|
-
assert_equal '34', BitStruct::BitSlicer.right_shifted( 0x12, 0x34, 0 ).hexify
|
|
18
|
-
assert_equal '23', BitStruct::BitSlicer.right_shifted( 0x12, 0x34, 4 ).hexify
|
|
19
|
-
assert_equal '12', BitStruct::BitSlicer.right_shifted( 0x12, 0x34, 8 ).hexify
|
|
20
|
-
end
|
|
21
|
-
|
|
22
|
-
def test_left_shifted
|
|
23
|
-
assert_equal '12', BitStruct::BitSlicer.left_shifted( 0x12, 0x34, 0 ).hexify
|
|
24
|
-
assert_equal '23', BitStruct::BitSlicer.left_shifted( 0x12, 0x34, 4 ).hexify
|
|
25
|
-
assert_equal '34', BitStruct::BitSlicer.left_shifted( 0x12, 0x34, 8 ).hexify
|
|
26
|
-
|
|
27
|
-
assert_equal '11000011', BitStruct::BitSlicer.left_shifted( 0xF0, 0xF0, 2 ).binarize
|
|
28
|
-
end
|
|
29
|
-
|
|
30
|
-
def test_first_byte
|
|
31
|
-
assert_equal 4, slicer( 0, 1 ).first_byte
|
|
32
|
-
assert_equal 4, slicer( 0, 7 ).first_byte
|
|
33
|
-
assert_equal 4, slicer( 0, 8 ).first_byte
|
|
34
|
-
assert_equal 3, slicer( 0, 12 ).first_byte
|
|
35
|
-
assert_equal 3, slicer( 0, 16 ).first_byte
|
|
36
|
-
assert_equal 3, slicer( 2, 8 ).first_byte
|
|
37
|
-
assert_equal 4, slicer( 2, 2 ).first_byte
|
|
38
|
-
assert_equal 2, slicer( 2, 16 ).first_byte
|
|
39
|
-
assert_equal 2, slicer( 4, 16 ).first_byte
|
|
40
|
-
assert_equal 2, slicer( 6, 16 ).first_byte
|
|
41
|
-
assert_equal 2, slicer( 7, 16 ).first_byte
|
|
42
|
-
assert_equal 2, slicer( 8, 16 ).first_byte
|
|
43
|
-
assert_equal 1, slicer( 9, 16 ).first_byte
|
|
44
|
-
assert_equal 1, slicer( 15, 16 ).first_byte
|
|
45
|
-
assert_equal 1, slicer( 16, 16 ).first_byte
|
|
46
|
-
assert_equal 0, slicer( 17, 16 ).first_byte
|
|
47
|
-
end
|
|
48
|
-
|
|
49
|
-
def test_last_byte
|
|
50
|
-
assert_equal 4, slicer( 0, 16 ).last_byte
|
|
51
|
-
assert_equal 4, slicer( 2, 16 ).last_byte
|
|
52
|
-
assert_equal 4, slicer( 4, 16 ).last_byte
|
|
53
|
-
assert_equal 4, slicer( 6, 16 ).last_byte
|
|
54
|
-
assert_equal 4, slicer( 7, 16 ).last_byte
|
|
55
|
-
assert_equal 3, slicer( 8, 16 ).last_byte
|
|
56
|
-
assert_equal 3, slicer( 9, 16 ).last_byte
|
|
57
|
-
assert_equal 3, slicer( 15, 16 ).last_byte
|
|
58
|
-
assert_equal 2, slicer( 16, 16 ).last_byte
|
|
59
|
-
assert_equal 2, slicer( 17, 16 ).last_byte
|
|
60
|
-
end
|
|
61
|
-
|
|
62
|
-
def test_length_in_bytes
|
|
63
|
-
assert_equal 1, slicer( 0, 1 ).length_in_bytes
|
|
64
|
-
assert_equal 1, slicer( 0, 4 ).length_in_bytes
|
|
65
|
-
assert_equal 1, slicer( 0, 8 ).length_in_bytes
|
|
66
|
-
assert_equal 2, slicer( 0, 9 ).length_in_bytes
|
|
67
|
-
assert_equal 2, slicer( 0, 14 ).length_in_bytes
|
|
68
|
-
assert_equal 2, slicer( 0, 16 ).length_in_bytes
|
|
69
|
-
assert_equal 3, slicer( 0, 20 ).length_in_bytes
|
|
70
|
-
|
|
71
|
-
assert_equal 1, slicer( 4, 1 ).length_in_bytes
|
|
72
|
-
assert_equal 1, slicer( 4, 4 ).length_in_bytes
|
|
73
|
-
assert_equal 1, slicer( 5, 8 ).length_in_bytes
|
|
74
|
-
assert_equal 2, slicer( 6, 9 ).length_in_bytes
|
|
75
|
-
assert_equal 2, slicer( 7, 14 ).length_in_bytes
|
|
76
|
-
assert_equal 2, slicer( 7, 16 ).length_in_bytes
|
|
77
|
-
assert_equal 3, slicer( 8, 20 ).length_in_bytes
|
|
78
|
-
end
|
|
79
|
-
|
|
80
|
-
def test_insert_length_in_bytes
|
|
81
|
-
assert_equal 1, slicer( 0, 1 ).insert_length_in_bytes
|
|
82
|
-
assert_equal 1, slicer( 0, 4 ).insert_length_in_bytes
|
|
83
|
-
assert_equal 1, slicer( 0, 8 ).insert_length_in_bytes
|
|
84
|
-
assert_equal 2, slicer( 0, 9 ).insert_length_in_bytes
|
|
85
|
-
assert_equal 2, slicer( 0, 14 ).insert_length_in_bytes
|
|
86
|
-
assert_equal 2, slicer( 0, 16 ).insert_length_in_bytes
|
|
87
|
-
assert_equal 3, slicer( 0, 20 ).insert_length_in_bytes
|
|
88
|
-
|
|
89
|
-
assert_equal 1, slicer( 8, 8 ).insert_length_in_bytes
|
|
90
|
-
|
|
91
|
-
assert_equal 1, slicer( 4, 1 ).insert_length_in_bytes
|
|
92
|
-
assert_equal 1, slicer( 4, 4 ).insert_length_in_bytes
|
|
93
|
-
assert_equal 2, slicer( 5, 8 ).insert_length_in_bytes
|
|
94
|
-
assert_equal 2, slicer( 6, 9 ).insert_length_in_bytes
|
|
95
|
-
assert_equal 3, slicer( 7, 14 ).insert_length_in_bytes
|
|
96
|
-
assert_equal 3, slicer( 7, 16 ).insert_length_in_bytes
|
|
97
|
-
assert_equal 3, slicer( 8, 20 ).insert_length_in_bytes
|
|
98
|
-
assert_equal 3, slicer( 8, 24 ).insert_length_in_bytes
|
|
99
|
-
assert_equal 4, slicer( 8, 25 ).insert_length_in_bytes
|
|
100
|
-
assert_equal 3, slicer( 9, 16 ).insert_length_in_bytes
|
|
101
|
-
end
|
|
102
|
-
|
|
103
|
-
def test_highest_byte_mask
|
|
104
|
-
assert_equal '00111111', slicer( 2, 22 ).highest_byte_mask.binarize
|
|
105
|
-
assert_equal '00111111', slicer( 0, 22 ).highest_byte_mask.binarize
|
|
106
|
-
assert_equal '11111111', slicer( 0, 16 ).highest_byte_mask.binarize
|
|
107
|
-
assert_equal '00111111', slicer( 2, 14 ).highest_byte_mask.binarize
|
|
108
|
-
assert_equal '11111111', slicer( 2, 16 ).highest_byte_mask.binarize
|
|
109
|
-
assert_equal '11111111', slicer( 4, 16 ).highest_byte_mask.binarize
|
|
110
|
-
assert_equal '11111111', slicer( 6, 16 ).highest_byte_mask.binarize
|
|
111
|
-
assert_equal '11111111', slicer( 7, 16 ).highest_byte_mask.binarize
|
|
112
|
-
assert_equal '11111111', slicer( 8, 16 ).highest_byte_mask.binarize
|
|
113
|
-
assert_equal '11111111', slicer( 9, 16 ).highest_byte_mask.binarize
|
|
114
|
-
assert_equal '11111111', slicer( 15, 16 ).highest_byte_mask.binarize
|
|
115
|
-
assert_equal '11111111', slicer( 16, 16 ).highest_byte_mask.binarize
|
|
116
|
-
assert_equal '11111111', slicer( 17, 16 ).highest_byte_mask.binarize
|
|
117
|
-
end
|
|
118
|
-
|
|
119
|
-
def test_insert_first_byte_mask
|
|
120
|
-
assert_equal '11111111', slicer( 0, 8 ).insert_first_byte_mask.binarize
|
|
121
|
-
assert_equal '00000011', slicer( 2, 8 ).insert_first_byte_mask.binarize
|
|
122
|
-
assert_equal '00001111', slicer( 4, 8 ).insert_first_byte_mask.binarize
|
|
123
|
-
assert_equal '00111111', slicer( 6, 8 ).insert_first_byte_mask.binarize
|
|
124
|
-
assert_equal '11111111', slicer( 8, 8 ).insert_first_byte_mask.binarize
|
|
125
|
-
assert_equal '00000011', slicer( 10, 8 ).insert_first_byte_mask.binarize
|
|
126
|
-
end
|
|
127
|
-
|
|
128
|
-
def test_insert_last_byte_mask
|
|
129
|
-
assert_equal '11111111', slicer( 0, 8 ).insert_last_byte_mask.binarize
|
|
130
|
-
assert_equal '11111100', slicer( 2, 8 ).insert_last_byte_mask.binarize
|
|
131
|
-
assert_equal '11110000', slicer( 4, 8 ).insert_last_byte_mask.binarize
|
|
132
|
-
assert_equal '11000000', slicer( 6, 8 ).insert_last_byte_mask.binarize
|
|
133
|
-
assert_equal '11111111', slicer( 8, 8 ).insert_last_byte_mask.binarize
|
|
134
|
-
end
|
|
135
|
-
|
|
136
|
-
def test_masked_last_byte
|
|
137
|
-
slicer = slicer( 12, 24 )
|
|
138
|
-
assert_equal '00000001', slicer.data[ slicer.first_byte ].binarize
|
|
139
|
-
assert_equal '11110000', slicer.merge_first_byte_mask.binarize
|
|
140
|
-
assert_equal '00000000', slicer.masked_first_byte.binarize
|
|
141
|
-
|
|
142
|
-
assert_equal '01100111', slicer.data[ slicer.last_byte ].binarize
|
|
143
|
-
assert_equal '00001111', slicer.merge_last_byte_mask.binarize
|
|
144
|
-
assert_equal '00000111', slicer.masked_last_byte.binarize
|
|
145
|
-
end
|
|
146
|
-
|
|
147
|
-
def test_required_shift
|
|
148
|
-
assert_equal 0, slicer( 0, 16 ).required_shift
|
|
149
|
-
assert_equal 2, slicer( 2, 16 ).required_shift
|
|
150
|
-
assert_equal 4, slicer( 4, 16 ).required_shift
|
|
151
|
-
assert_equal 6, slicer( 6, 16 ).required_shift
|
|
152
|
-
assert_equal 0, slicer( 8, 4 ).required_shift
|
|
153
|
-
assert_equal 0, slicer( 8, 16 ).required_shift
|
|
154
|
-
assert_equal 2, slicer( 10, 16 ).required_shift
|
|
155
|
-
end
|
|
156
|
-
|
|
157
|
-
def test_get_raw_bytes
|
|
158
|
-
# test_data = [ 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
|
|
159
|
-
|
|
160
|
-
assert_equal '0x89', slicer( 0, 8 ).get_raw_bytes.hexify
|
|
161
|
-
assert_equal '0x67 0x89', slicer( 0, 16 ).get_raw_bytes.hexify
|
|
162
|
-
assert_equal '0x45 0x67 0x89', slicer( 0, 24 ).get_raw_bytes.hexify
|
|
163
|
-
|
|
164
|
-
assert_equal '0x45 0x67 0x89', slicer( 4, 16 ).get_raw_bytes.hexify
|
|
165
|
-
assert_equal '0x45 0x67 0x89', slicer( 4, 20 ).get_raw_bytes.hexify
|
|
166
|
-
assert_equal '0x23 0x45 0x67 0x89', slicer( 6, 20 ).get_raw_bytes.hexify
|
|
167
|
-
|
|
168
|
-
assert_equal '0x45 0x67', slicer( 12, 8 ).get_raw_bytes.hexify
|
|
169
|
-
|
|
170
|
-
assert_equal '0x67', slicer( 8, 4 ).get_raw_bytes.hexify
|
|
171
|
-
|
|
172
|
-
assert_equal '0x45 0x67', slicer( 8, 16 ).get_raw_bytes.hexify
|
|
173
|
-
assert_equal '0x23 0x45', slicer( 16, 16 ).get_raw_bytes.hexify
|
|
174
|
-
end
|
|
175
|
-
|
|
176
|
-
def test_shift_bytes_right
|
|
177
|
-
assert_equal '0x01 0x23 0x45', BitStruct::BitSlicer.shift_bytes_right( [ 0x12, 0x34, 0x56 ], 4 ).hexify
|
|
178
|
-
assert_equal '0x00 0x12 0x34', BitStruct::BitSlicer.shift_bytes_right( [ 0x12, 0x34, 0x56 ], 8 ).hexify
|
|
179
|
-
end
|
|
180
|
-
|
|
181
|
-
def test_shift_bytes_left
|
|
182
|
-
assert_equal '0x23 0x45 0x60', BitStruct::BitSlicer.shift_bytes_left( [ 0x12, 0x34, 0x56 ], 4 ).hexify
|
|
183
|
-
assert_equal '0x34 0x56 0x00', BitStruct::BitSlicer.shift_bytes_left( [ 0x12, 0x34, 0x56 ], 8 ).hexify
|
|
184
|
-
end
|
|
185
|
-
|
|
186
|
-
def test_get_bytes
|
|
187
|
-
assert_equal '0x89', slicer( 0, 8 ).get_bytes.hexify
|
|
188
|
-
assert_equal '0x09', slicer( 0, 4 ).get_bytes.hexify
|
|
189
|
-
assert_equal '0x08', slicer( 4, 4 ).get_bytes.hexify
|
|
190
|
-
|
|
191
|
-
assert_equal '0x07', slicer( 8, 4 ).get_bytes.hexify
|
|
192
|
-
assert_equal '0x06', slicer( 12, 4 ).get_bytes.hexify
|
|
193
|
-
|
|
194
|
-
assert_equal '0x67 0x89', slicer( 4, 8 ).get_raw_bytes.hexify
|
|
195
|
-
assert_equal '0x06 0x78', BitStruct::BitSlicer.shift_bytes_right( [ 0x67, 0x89 ], 4 ).hexify
|
|
196
|
-
assert_equal '0x78', slicer( 4, 8 ).get_bytes.hexify
|
|
197
|
-
|
|
198
|
-
assert_equal '0x45 0x67', slicer( 12, 8 ).get_raw_bytes.hexify
|
|
199
|
-
assert_equal '0x04 0x56', BitStruct::BitSlicer.shift_bytes_right( [ 0x45, 0x67 ], 4 ).hexify
|
|
200
|
-
assert_equal '0x56', slicer( 12, 8 ).get_bytes.hexify
|
|
201
|
-
|
|
202
|
-
assert_equal '0x67 0x89', slicer( 0, 16 ).get_bytes.hexify
|
|
203
|
-
assert_equal '0x45 0x67 0x89', slicer( 0, 24 ).get_bytes.hexify
|
|
204
|
-
assert_equal '0x05 0x67 0x89', slicer( 0, 22 ).get_bytes.hexify
|
|
205
|
-
|
|
206
|
-
assert_equal '0x45 0x67', slicer( 8, 16 ).get_bytes.hexify
|
|
207
|
-
assert_equal '0x23 0x45', slicer( 16, 16 ).get_bytes.hexify
|
|
208
|
-
|
|
209
|
-
assert_equal '0x23 0x45 0x67', slicer( 12, 16 ).get_raw_bytes.hexify
|
|
210
|
-
assert_equal '0x34 0x56', slicer( 12, 16 ).get_bytes.hexify
|
|
211
|
-
assert_equal '0x04 0x56', slicer( 12, 12 ).get_bytes.hexify
|
|
212
|
-
assert_equal '0x56', slicer( 12, 8 ).get_bytes.hexify
|
|
213
|
-
assert_equal '0x16', slicer( 12, 6 ).get_bytes.hexify
|
|
214
|
-
assert_equal '0x06', slicer( 12, 4 ).get_bytes.hexify
|
|
215
|
-
assert_equal '0x02', slicer( 12, 2 ).get_bytes.hexify
|
|
216
|
-
end
|
|
217
|
-
|
|
218
|
-
def test_set_bytes
|
|
219
|
-
slicer = slicer( 0, 8 )
|
|
220
|
-
assert_equal 4, slicer.first_byte
|
|
221
|
-
assert_equal 4, slicer.last_byte
|
|
222
|
-
assert_equal 1, slicer.length_in_bytes
|
|
223
|
-
assert_equal 1, slicer.insert_length_in_bytes
|
|
224
|
-
assert_equal 4, slicer.first_byte
|
|
225
|
-
assert_equal 4, slicer.last_byte
|
|
226
|
-
# assert_equal '0x01 0x23 0x45 0x67 0xcd', slicer.set_bytes( [ 0xCD ] ).hexify
|
|
227
|
-
|
|
228
|
-
slicer = slicer( 8, 8 )
|
|
229
|
-
assert_equal 3, slicer.first_byte
|
|
230
|
-
assert_equal 3, slicer.last_byte
|
|
231
|
-
assert_equal 1, slicer.length_in_bytes
|
|
232
|
-
assert_equal 1, slicer.insert_length_in_bytes
|
|
233
|
-
# assert_equal '0x01 0x23 0x45 0xcd 0x89', slicer.set_bytes( [ 0xCD ] ).hexify
|
|
234
|
-
|
|
235
|
-
slicer = slicer( 4, 8 )
|
|
236
|
-
assert_equal 3, slicer.first_byte
|
|
237
|
-
assert_equal 4, slicer.last_byte
|
|
238
|
-
assert_equal 1, slicer.length_in_bytes
|
|
239
|
-
assert_equal 2, slicer.insert_length_in_bytes
|
|
240
|
-
# assert_equal '0x01 0x23 0x45 0x6c 0xd9', slicer.set_bytes( [ 0xCD ] ).hexify
|
|
241
|
-
|
|
242
|
-
slicer = slicer( 4, 2 )
|
|
243
|
-
assert_equal 4, slicer.first_byte
|
|
244
|
-
assert_equal 4, slicer.last_byte
|
|
245
|
-
assert_equal 1, slicer.length_in_bytes
|
|
246
|
-
assert_equal 1, slicer.insert_length_in_bytes
|
|
247
|
-
|
|
248
|
-
assert_equal '00111111', slicer.insert_first_byte_mask.binarize
|
|
249
|
-
assert_equal '11110000', slicer.insert_last_byte_mask.binarize
|
|
250
|
-
|
|
251
|
-
assert_equal '11000000', slicer.merge_first_byte_mask.binarize
|
|
252
|
-
assert_equal '00001111', slicer.merge_last_byte_mask.binarize
|
|
253
|
-
|
|
254
|
-
assert_equal '10000000', slicer.masked_first_byte.binarize
|
|
255
|
-
assert_equal '00001001', slicer.masked_last_byte.binarize
|
|
256
|
-
|
|
257
|
-
assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.data.hexify
|
|
258
|
-
assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.set_bytes( [ 0x00 ] ).hexify
|
|
259
|
-
assert_equal '0x01 0x23 0x45 0x67 0xb9', slicer.set_bytes( [ 0xFF ] ).hexify
|
|
260
|
-
|
|
261
|
-
slicer = slicer( 12, 24 )
|
|
262
|
-
assert_equal 0, slicer.first_byte
|
|
263
|
-
assert_equal 3, slicer.last_byte
|
|
264
|
-
assert_equal 3, slicer.length_in_bytes
|
|
265
|
-
assert_equal 4, slicer.insert_length_in_bytes
|
|
266
|
-
|
|
267
|
-
assert_equal '00001111', slicer.insert_first_byte_mask.binarize
|
|
268
|
-
assert_equal '11110000', slicer.insert_last_byte_mask.binarize
|
|
269
|
-
|
|
270
|
-
assert_equal '11110000', slicer.merge_first_byte_mask.binarize
|
|
271
|
-
assert_equal '00001111', slicer.merge_last_byte_mask.binarize
|
|
272
|
-
|
|
273
|
-
assert_equal '00000001', slicer.data[ slicer.first_byte ].binarize
|
|
274
|
-
assert_equal '00000000', slicer.masked_first_byte.binarize
|
|
275
|
-
|
|
276
|
-
assert_equal '01100111', slicer.data[ slicer.last_byte ].binarize
|
|
277
|
-
assert_equal '00000111', slicer.masked_last_byte.binarize
|
|
278
|
-
|
|
279
|
-
assert_equal '0x01 0x23 0x45 0x67 0x89', slicer.data.hexify
|
|
280
|
-
assert_equal '0x12 0x34 0x56', slicer.get_bytes.hexify
|
|
281
|
-
assert_equal '0x07 0x75 0x53 0x37 0x89', slicer.set_bytes( [ 0x99, 0x77, 0x55, 0x33 ] ).hexify
|
|
282
|
-
assert_equal '0x07 0x75 0x53 0x37 0x89', slicer.set_bytes( [ 0xAA, 0xFF, 0x99, 0x77, 0x55, 0x33 ] ).hexify
|
|
283
|
-
end
|
|
284
|
-
|
|
285
|
-
def slicer( bit_offset, bit_length )
|
|
286
|
-
slicer = BitStruct::BitSlicer.new bit_offset, bit_length
|
|
287
|
-
slicer.data = test_data.dup
|
|
288
|
-
slicer
|
|
289
|
-
end
|
|
290
|
-
|
|
291
|
-
def test_data
|
|
292
|
-
[ 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
|
|
293
|
-
end
|
|
294
|
-
|
|
295
|
-
def test_data_intel
|
|
296
|
-
[ 0x89, 0x67, 0x45, 0x23, 0x01].pack( 'C*' )
|
|
297
|
-
end
|
|
298
|
-
|
|
299
|
-
end
|
|
@@ -1,127 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
require 'test/unit'
|
|
3
|
-
|
|
4
|
-
require 'bit_struct/struct_base'
|
|
5
|
-
|
|
6
|
-
include BitStruct
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
class Flags < StructBase
|
|
11
|
-
unsigned :direction, 4
|
|
12
|
-
unsigned :multiplier, 2
|
|
13
|
-
unsigned :offset, 2
|
|
14
|
-
end
|
|
15
|
-
|
|
16
|
-
class Entry < StructBase
|
|
17
|
-
unsigned :offset, 4
|
|
18
|
-
nested :flags, Flags
|
|
19
|
-
unsigned :address, 24
|
|
20
|
-
unsigned :cache_id, 16
|
|
21
|
-
end
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
class TestBitStruct < Test::Unit::TestCase
|
|
26
|
-
|
|
27
|
-
def test_flags_class
|
|
28
|
-
fields = Flags.fields
|
|
29
|
-
assert_equal 3, fields.size
|
|
30
|
-
|
|
31
|
-
assert_equal :direction, fields[ 0 ].name
|
|
32
|
-
assert_equal 4, fields[ 0 ].length
|
|
33
|
-
assert_equal :multiplier, fields[ 1 ].name
|
|
34
|
-
assert_equal 2, fields[ 1 ].length
|
|
35
|
-
assert_equal :offset, fields[ 2 ].name
|
|
36
|
-
assert_equal 2, fields[ 2 ].length
|
|
37
|
-
end
|
|
38
|
-
|
|
39
|
-
def test_attributes_class
|
|
40
|
-
fields = Entry.fields
|
|
41
|
-
assert_equal 4, fields.size
|
|
42
|
-
|
|
43
|
-
assert_equal :offset, fields[ 0 ].name
|
|
44
|
-
assert_equal 4, fields[ 0 ].length
|
|
45
|
-
assert_equal :flags, fields[ 1 ].name
|
|
46
|
-
assert_equal 8, fields[ 1 ].length
|
|
47
|
-
assert_equal :address, fields[ 2 ].name
|
|
48
|
-
assert_equal 24, fields[ 2 ].length
|
|
49
|
-
assert_equal :cache_id, fields[ 3 ].name
|
|
50
|
-
assert_equal 16, fields[ 3 ].length
|
|
51
|
-
end
|
|
52
|
-
|
|
53
|
-
def test_flags_read
|
|
54
|
-
flags = Flags.new [ 0xFF ].pack( 'C*' )
|
|
55
|
-
assert_equal 0x0F, flags.direction
|
|
56
|
-
assert_equal 0x03, flags.multiplier
|
|
57
|
-
assert_equal 0x03, flags.offset
|
|
58
|
-
|
|
59
|
-
flags = Flags.new [ 0x0F ].pack( 'C*' )
|
|
60
|
-
assert_equal 0x0F, flags.direction
|
|
61
|
-
assert_equal 0x00, flags.multiplier
|
|
62
|
-
assert_equal 0x00, flags.offset
|
|
63
|
-
|
|
64
|
-
flags = Flags.new [ 0x3F ].pack( 'C*' )
|
|
65
|
-
assert_equal 0x0F, flags.direction
|
|
66
|
-
assert_equal 0x03, flags.multiplier
|
|
67
|
-
assert_equal 0x00, flags.offset
|
|
68
|
-
|
|
69
|
-
flags = Flags.new [ 0xCF ].pack( 'C*' )
|
|
70
|
-
assert_equal 0x0F, flags.direction
|
|
71
|
-
assert_equal 0x00, flags.multiplier
|
|
72
|
-
assert_equal 0x03, flags.offset
|
|
73
|
-
end
|
|
74
|
-
|
|
75
|
-
def test_flags_write
|
|
76
|
-
data = [ 0xFF ].pack( 'C*' )
|
|
77
|
-
|
|
78
|
-
flags = Flags.new data
|
|
79
|
-
assert_equal '0xff', flags.data.hexify
|
|
80
|
-
assert_equal 0x0F, flags.direction
|
|
81
|
-
assert_equal 0x03, flags.multiplier
|
|
82
|
-
assert_equal 0x03, flags.offset
|
|
83
|
-
|
|
84
|
-
flags.multiplier = 0
|
|
85
|
-
assert_equal '0xcf', flags.data.hexify
|
|
86
|
-
assert_equal 0x0F, flags.direction
|
|
87
|
-
assert_equal 0x00, flags.multiplier
|
|
88
|
-
assert_equal 0x03, flags.offset
|
|
89
|
-
end
|
|
90
|
-
|
|
91
|
-
def test_entry_read
|
|
92
|
-
data = [ 0xAA, 0xFF, 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
|
|
93
|
-
entry = Entry.new data
|
|
94
|
-
|
|
95
|
-
assert_equal 9, entry.offset
|
|
96
|
-
assert_equal '0x12 0x34 0x56', entry.address.bytes.hexify
|
|
97
|
-
assert_equal '0xaf 0xf0', entry.cache_id.bytes.hexify
|
|
98
|
-
|
|
99
|
-
flags = entry.flags
|
|
100
|
-
assert_equal 8, flags.direction
|
|
101
|
-
assert_equal 3, flags.multiplier
|
|
102
|
-
assert_equal 1, flags.offset
|
|
103
|
-
end
|
|
104
|
-
|
|
105
|
-
def test_attributes_write
|
|
106
|
-
data = [ 0xAA, 0xFF, 0x01, 0x23, 0x45, 0x67, 0x89 ].pack( 'C*' )
|
|
107
|
-
entry = Entry.new data
|
|
108
|
-
|
|
109
|
-
entry.offset = 15
|
|
110
|
-
assert_equal '0x0f', entry.offset.bytes.hexify
|
|
111
|
-
assert_equal '0xaa 0xff 0x01 0x23 0x45 0x67 0x8f', entry.data.hexify
|
|
112
|
-
|
|
113
|
-
entry.address = 0x44332211
|
|
114
|
-
assert_equal '0x33 0x22 0x11', entry.address.bytes.hexify
|
|
115
|
-
assert_equal '0xaa 0xff 0x03 0x32 0x21 0x17 0x8f', entry.data.hexify
|
|
116
|
-
|
|
117
|
-
entry.cache_id = 0xAABBCCDD
|
|
118
|
-
assert_equal '0xcc 0xdd', entry.cache_id.bytes.hexify
|
|
119
|
-
assert_equal '0xac 0xcd 0xd3 0x32 0x21 0x17 0x8f', entry.data.hexify
|
|
120
|
-
|
|
121
|
-
flags = entry.flags
|
|
122
|
-
assert_equal 8, flags.direction
|
|
123
|
-
assert_equal 3, flags.multiplier
|
|
124
|
-
assert_equal 1, flags.offset
|
|
125
|
-
end
|
|
126
|
-
|
|
127
|
-
end
|
|
@@ -1,54 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
require 'test/unit'
|
|
3
|
-
|
|
4
|
-
require 'bit_struct/text'
|
|
5
|
-
|
|
6
|
-
include BitStruct
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
class TestTextField < Test::Unit::TestCase
|
|
11
|
-
|
|
12
|
-
# Note: The TextField doesn't check the length. It is part of the
|
|
13
|
-
# contract between the field and the slicer that only the expected
|
|
14
|
-
# number of bytes (or less) are passed to the field :)
|
|
15
|
-
|
|
16
|
-
def test_initialize
|
|
17
|
-
TextField.new 'dummy', 8
|
|
18
|
-
TextField.new 'dummy', 16
|
|
19
|
-
TextField.new 'dummy', 24
|
|
20
|
-
assert_raise( RuntimeError ) { TextField.new 'dummy', 5 }
|
|
21
|
-
end
|
|
22
|
-
|
|
23
|
-
def test_read
|
|
24
|
-
slicer = FakeSlicer.new 'toast'.bytes
|
|
25
|
-
field = TextField.new 'dummy', 24
|
|
26
|
-
assert_equal 'tsaot', field.read( slicer )
|
|
27
|
-
end
|
|
28
|
-
|
|
29
|
-
def test_write
|
|
30
|
-
slicer = FakeSlicer.new
|
|
31
|
-
field = TextField.new 'dummy', 24
|
|
32
|
-
field.write slicer, 'toast'
|
|
33
|
-
assert_equal 'tsaot', slicer.get_bytes.stringify
|
|
34
|
-
end
|
|
35
|
-
|
|
36
|
-
end
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
class FakeSlicer
|
|
41
|
-
|
|
42
|
-
def initialize( data = '' )
|
|
43
|
-
@data = data
|
|
44
|
-
end
|
|
45
|
-
|
|
46
|
-
def get_bytes
|
|
47
|
-
@data
|
|
48
|
-
end
|
|
49
|
-
|
|
50
|
-
def set_bytes( data )
|
|
51
|
-
@data = data
|
|
52
|
-
end
|
|
53
|
-
|
|
54
|
-
end
|
|
@@ -1,58 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
require 'test/unit'
|
|
3
|
-
|
|
4
|
-
require 'bit_struct/struct_base'
|
|
5
|
-
|
|
6
|
-
include BitStruct
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
class TestTextStruct < Test::Unit::TestCase
|
|
11
|
-
|
|
12
|
-
class AlignedText < StructBase
|
|
13
|
-
unsigned :before, 8
|
|
14
|
-
text :aligned, 32
|
|
15
|
-
unsigned :after, 8
|
|
16
|
-
end
|
|
17
|
-
|
|
18
|
-
def test_aligned_text
|
|
19
|
-
data = [ 0x12, ?t, ?s, ?e, ?t, 0x34 ].pack( 'C*' )
|
|
20
|
-
struct = AlignedText.new data
|
|
21
|
-
assert_equal 0x34, struct.before
|
|
22
|
-
assert_equal 'test', struct.aligned
|
|
23
|
-
assert_equal 0x12, struct.after
|
|
24
|
-
|
|
25
|
-
struct.before = ?A
|
|
26
|
-
struct.aligned = 'goal'
|
|
27
|
-
struct.after = ?B
|
|
28
|
-
assert_equal ?A, struct.before
|
|
29
|
-
assert_equal 'goal', struct.aligned
|
|
30
|
-
assert_equal ?B, struct.after
|
|
31
|
-
|
|
32
|
-
assert_equal 'BlaogA', struct.data
|
|
33
|
-
end
|
|
34
|
-
|
|
35
|
-
class UnalignedText < StructBase
|
|
36
|
-
unsigned :before, 4
|
|
37
|
-
text :unaligned, 24
|
|
38
|
-
unsigned :after, 4
|
|
39
|
-
end
|
|
40
|
-
|
|
41
|
-
def test_unaligned_text
|
|
42
|
-
a_hi, a_lo = get_hi_lo ?a
|
|
43
|
-
b_hi, b_lo = get_hi_lo ?b
|
|
44
|
-
c_hi, c_lo = get_hi_lo ?c
|
|
45
|
-
|
|
46
|
-
data = [ 12 << 4 | c_hi, c_lo << 4 | b_hi, b_lo << 4 | a_hi, a_lo << 4 | 3 ].pack( 'C*' )
|
|
47
|
-
|
|
48
|
-
struct = UnalignedText.new data
|
|
49
|
-
assert_equal 3, struct.before
|
|
50
|
-
assert_equal 'abc', struct.unaligned
|
|
51
|
-
assert_equal 12, struct.after
|
|
52
|
-
end
|
|
53
|
-
|
|
54
|
-
def get_hi_lo( char )
|
|
55
|
-
return char >> 4, char & 0x0F
|
|
56
|
-
end
|
|
57
|
-
|
|
58
|
-
end
|
data/test/ruby/runner.rb
DELETED
|
@@ -1,127 +0,0 @@
|
|
|
1
|
-
|
|
2
|
-
require 'logger'
|
|
3
|
-
|
|
4
|
-
require 'test/unit/autorunner'
|
|
5
|
-
|
|
6
|
-
class String
|
|
7
|
-
|
|
8
|
-
def bytes
|
|
9
|
-
bytes = []
|
|
10
|
-
self.each_byte { |b| bytes << b }
|
|
11
|
-
bytes
|
|
12
|
-
end
|
|
13
|
-
|
|
14
|
-
def hexify
|
|
15
|
-
result = ''
|
|
16
|
-
each_byte do |b|
|
|
17
|
-
result << "0x#{b.hexify} "
|
|
18
|
-
end
|
|
19
|
-
result.chop
|
|
20
|
-
end
|
|
21
|
-
|
|
22
|
-
end
|
|
23
|
-
|
|
24
|
-
class Array
|
|
25
|
-
|
|
26
|
-
def stringify
|
|
27
|
-
res = ''
|
|
28
|
-
self.each { |b| res << b }
|
|
29
|
-
res
|
|
30
|
-
end
|
|
31
|
-
|
|
32
|
-
def hexify
|
|
33
|
-
map { |b| "0x#{b && b.hexify}" }.join( ' ' )
|
|
34
|
-
end
|
|
35
|
-
|
|
36
|
-
def binarize
|
|
37
|
-
map { |b| "%#{b && b.binarize}" }.join( ' ' )
|
|
38
|
-
end
|
|
39
|
-
|
|
40
|
-
end
|
|
41
|
-
|
|
42
|
-
class Fixnum
|
|
43
|
-
|
|
44
|
-
def bytes
|
|
45
|
-
bytes = []
|
|
46
|
-
val = to_i
|
|
47
|
-
while val > 0
|
|
48
|
-
bytes.insert 0, ( val & 0xFF )
|
|
49
|
-
val >>= 8
|
|
50
|
-
end
|
|
51
|
-
bytes
|
|
52
|
-
end
|
|
53
|
-
|
|
54
|
-
def hexify
|
|
55
|
-
result = ''
|
|
56
|
-
val = to_i
|
|
57
|
-
while val > 0
|
|
58
|
-
b = val & 0xF
|
|
59
|
-
result = b.to_s( 16 ) + result
|
|
60
|
-
val >>= 4
|
|
61
|
-
end
|
|
62
|
-
padded result, 2
|
|
63
|
-
end
|
|
64
|
-
|
|
65
|
-
def binarize
|
|
66
|
-
result = ''
|
|
67
|
-
val = to_i
|
|
68
|
-
while val > 0
|
|
69
|
-
b = val & 1
|
|
70
|
-
result = b.to_s( 2 ) + result
|
|
71
|
-
val >>= 1
|
|
72
|
-
end
|
|
73
|
-
padded result, 8
|
|
74
|
-
end
|
|
75
|
-
|
|
76
|
-
def padded( val, length_multiplier )
|
|
77
|
-
padded_length = ( val.length / length_multiplier ).ceil * length_multiplier
|
|
78
|
-
padded_length = length_multiplier if padded_length == 0
|
|
79
|
-
pad_size = padded_length - val.length
|
|
80
|
-
'0' * pad_size + val
|
|
81
|
-
end
|
|
82
|
-
|
|
83
|
-
end
|
|
84
|
-
|
|
85
|
-
def hexify( data )
|
|
86
|
-
result = ''
|
|
87
|
-
data.each_byte do |b|
|
|
88
|
-
nibble = ( b >> 4 ) & 15
|
|
89
|
-
result << ( 0x30 + nibble ) if nibble < 10
|
|
90
|
-
result << ( 0x41 + nibble - 10 ) if nibble >= 10
|
|
91
|
-
nibble = ( b >> 0 ) & 15
|
|
92
|
-
result << ( 0x30 + nibble ) if nibble < 10
|
|
93
|
-
result << ( 0x41 + nibble - 10 ) if nibble >= 10
|
|
94
|
-
end
|
|
95
|
-
result
|
|
96
|
-
end
|
|
97
|
-
|
|
98
|
-
def get_resource( basedir, relative_filename )
|
|
99
|
-
basedir = File.dirname basedir unless File.directory? basedir
|
|
100
|
-
filename = File.join( basedir, relative_filename )
|
|
101
|
-
raise "Resource not found: #{filename}" unless File.exists? filename
|
|
102
|
-
return filename
|
|
103
|
-
end
|
|
104
|
-
|
|
105
|
-
def open_resource( basedir, relative_filename )
|
|
106
|
-
File.new get_resource( basedir, relative_filename ), 'rb'
|
|
107
|
-
end
|
|
108
|
-
|
|
109
|
-
def load_resource( basedir, relative_filename )
|
|
110
|
-
File.open( get_resource( basedir, relative_filename ), 'rb' ) do |file|
|
|
111
|
-
return file.read
|
|
112
|
-
end
|
|
113
|
-
end
|
|
114
|
-
|
|
115
|
-
class NullLogger < Logger
|
|
116
|
-
def initialize( *args )
|
|
117
|
-
super STDOUT
|
|
118
|
-
@level = WARN
|
|
119
|
-
end
|
|
120
|
-
end
|
|
121
|
-
|
|
122
|
-
NULL_LOGGER = NullLogger.new
|
|
123
|
-
|
|
124
|
-
args = [ '--runner=console', '--verbose=v' ]
|
|
125
|
-
args.concat ARGV
|
|
126
|
-
success = Test::Unit::AutoRunner.run( true, File.dirname( $0 ), args )
|
|
127
|
-
exit 10 unless success
|