BitStructEx 0.0.64 → 0.0.65
Sign up to get free protection for your applications and to get access to all the features.
- 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
|