From 6ee36c1403ce410688d2d0f918e2c6d7dc5d1cb3 Mon Sep 17 00:00:00 2001
From: Kazuki Yamaguchi <k@rhe.jp>
Date: Thu, 8 Sep 2016 22:23:22 +0900
Subject: test/test_asn1: remove pointless begin-end

---
 test/test_asn1.rb | 310 +++++++++++++++++++++---------------------------------
 1 file changed, 117 insertions(+), 193 deletions(-)

(limited to 'test')

diff --git a/test/test_asn1.rb b/test/test_asn1.rb
index f226da5c..612c59a2 100644
--- a/test/test_asn1.rb
+++ b/test/test_asn1.rb
@@ -243,14 +243,9 @@ rEzBQ0F9dUyqQ9gyRg8KHhDfv9HzT1d/rnUZMkoombwYBRIUChGCYV0GnJcan2Zm
   end
 
   def test_primitive_cannot_set_infinite_length
-    begin
-      prim = OpenSSL::ASN1::Integer.new(50)
-      assert_equal(false, prim.infinite_length)
-      prim.infinite_length = true
-      flunk('Could set infinite length on primitive value')
-    rescue NoMethodError
-      #ok
-    end
+    prim = OpenSSL::ASN1::Integer.new(50)
+    assert_equal false, prim.infinite_length
+    assert_not_respond_to prim, :infinite_length=
   end
 
   def test_decode_all
@@ -289,12 +284,8 @@ rEzBQ0F9dUyqQ9gyRg8KHhDfv9HzT1d/rnUZMkoombwYBRIUChGCYV0GnJcan2Zm
   def test_create_inf_length_primitive
     expected = %w{ 24 80 04 01 61 00 00 }
     raw = [expected.join('')].pack('H*')
-    val = OpenSSL::ASN1::OctetString.new('a')
-    cons = OpenSSL::ASN1::Constructive.new([val,
-                                            OpenSSL::ASN1::EndOfContent.new],
-                                            OpenSSL::ASN1::OCTET_STRING,
-                                            nil,
-                                            :UNIVERSAL)
+    content = [OpenSSL::ASN1::OctetString.new("a"), OpenSSL::ASN1::EndOfContent.new]
+    cons = OpenSSL::ASN1::Constructive.new(content, OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
     cons.infinite_length = true
     assert_equal(nil, cons.tagging)
     assert_equal(raw, cons.to_der)
@@ -306,10 +297,7 @@ rEzBQ0F9dUyqQ9gyRg8KHhDfv9HzT1d/rnUZMkoombwYBRIUChGCYV0GnJcan2Zm
   def test_cons_without_inf_length_forbidden
     assert_raise(OpenSSL::ASN1::ASN1Error) do
       val = OpenSSL::ASN1::OctetString.new('a')
-      cons = OpenSSL::ASN1::Constructive.new([val],
-                                            OpenSSL::ASN1::OCTET_STRING,
-                                            nil,
-                                            :UNIVERSAL)
+      cons = OpenSSL::ASN1::Constructive.new([val], OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
       cons.to_der
     end
   end
@@ -317,10 +305,7 @@ rEzBQ0F9dUyqQ9gyRg8KHhDfv9HzT1d/rnUZMkoombwYBRIUChGCYV0GnJcan2Zm
   def test_cons_without_array_forbidden
     assert_raise(OpenSSL::ASN1::ASN1Error) do
       val = OpenSSL::ASN1::OctetString.new('a')
-      cons = OpenSSL::ASN1::Constructive.new(val,
-                                            OpenSSL::ASN1::OCTET_STRING,
-                                            nil,
-                                            :UNIVERSAL)
+      cons = OpenSSL::ASN1::Constructive.new(val, OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
       cons.infinite_length = true
       cons.to_der
     end
@@ -352,218 +337,158 @@ rEzBQ0F9dUyqQ9gyRg8KHhDfv9HzT1d/rnUZMkoombwYBRIUChGCYV0GnJcan2Zm
   end
 
   def test_seq_infinite_length
-    begin
-      content = [ OpenSSL::ASN1::Null.new(nil),
-                  OpenSSL::ASN1::EndOfContent.new ]
-      cons = OpenSSL::ASN1::Sequence.new(content)
-      cons.infinite_length = true
-      expected = %w{ 30 80 05 00 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::Null.new(nil),
+                OpenSSL::ASN1::EndOfContent.new ]
+    cons = OpenSSL::ASN1::Sequence.new(content)
+    cons.infinite_length = true
+    expected = %w{ 30 80 05 00 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_set_infinite_length
-    begin
-      content = [ OpenSSL::ASN1::Null.new(nil),
-                  OpenSSL::ASN1::EndOfContent.new() ]
-      cons = OpenSSL::ASN1::Set.new(content)
-      cons.infinite_length = true
-      expected = %w{ 31 80 05 00 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::Null.new(nil),
+                OpenSSL::ASN1::EndOfContent.new() ]
+    cons = OpenSSL::ASN1::Set.new(content)
+    cons.infinite_length = true
+    expected = %w{ 31 80 05 00 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_octet_string_infinite_length
-    begin
-      octets = [ OpenSSL::ASN1::OctetString.new('aaa'),
-                 OpenSSL::ASN1::EndOfContent.new() ]
-      cons = OpenSSL::ASN1::Constructive.new(
-        octets,
-        OpenSSL::ASN1::OCTET_STRING,
-        nil,
-        :UNIVERSAL)
-      cons.infinite_length = true
-      expected = %w{ 24 80 04 03 61 61 61 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    octets = [ OpenSSL::ASN1::OctetString.new('aaa'),
+               OpenSSL::ASN1::EndOfContent.new() ]
+    cons = OpenSSL::ASN1::Constructive.new(octets, OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
+    cons.infinite_length = true
+    expected = %w{ 24 80 04 03 61 61 61 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_prim_explicit_tagging
-    begin
-      oct_str = OpenSSL::ASN1::OctetString.new("a", 0, :EXPLICIT)
-      expected = %w{ A0 03 04 01 61 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, oct_str.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    oct_str = OpenSSL::ASN1::OctetString.new("a", 0, :EXPLICIT)
+    expected = %w{ A0 03 04 01 61 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, oct_str.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_prim_explicit_tagging_tag_class
-    begin
-      oct_str = OpenSSL::ASN1::OctetString.new("a", 0, :EXPLICIT)
-      oct_str2 = OpenSSL::ASN1::OctetString.new(
-        "a",
-        0,
-        :EXPLICIT,
-        :CONTEXT_SPECIFIC)
-      assert_equal(oct_str.to_der, oct_str2.to_der)
-    end
+    oct_str = OpenSSL::ASN1::OctetString.new("a", 0, :EXPLICIT)
+    oct_str2 = OpenSSL::ASN1::OctetString.new("a", 0, :EXPLICIT, :CONTEXT_SPECIFIC)
+    assert_equal(oct_str.to_der, oct_str2.to_der)
   end
 
   def test_prim_implicit_tagging
-    begin
-      int = OpenSSL::ASN1::Integer.new(1, 0, :IMPLICIT)
-      expected = %w{ 80 01 01 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, int.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    int = OpenSSL::ASN1::Integer.new(1, 0, :IMPLICIT)
+    expected = %w{ 80 01 01 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, int.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_prim_implicit_tagging_tag_class
-    begin
-      int = OpenSSL::ASN1::Integer.new(1, 0, :IMPLICIT)
-      int2 = OpenSSL::ASN1::Integer.new(1, 0, :IMPLICIT, :CONTEXT_SPECIFIC);
-      assert_equal(int.to_der, int2.to_der)
-    end
+    int = OpenSSL::ASN1::Integer.new(1, 0, :IMPLICIT)
+    int2 = OpenSSL::ASN1::Integer.new(1, 0, :IMPLICIT, :CONTEXT_SPECIFIC);
+    assert_equal(int.to_der, int2.to_der)
   end
 
   def test_cons_explicit_tagging
-    begin
-      content = [ OpenSSL::ASN1::PrintableString.new('abc') ]
-      seq = OpenSSL::ASN1::Sequence.new(content, 2, :EXPLICIT)
-      expected = %w{ A2 07 30 05 13 03 61 62 63 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, seq.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::PrintableString.new('abc') ]
+    seq = OpenSSL::ASN1::Sequence.new(content, 2, :EXPLICIT)
+    expected = %w{ A2 07 30 05 13 03 61 62 63 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, seq.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_cons_explicit_tagging_inf_length
-    begin
-      content = [ OpenSSL::ASN1::PrintableString.new('abc') ,
-                  OpenSSL::ASN1::EndOfContent.new() ]
-      seq = OpenSSL::ASN1::Sequence.new(content, 2, :EXPLICIT)
-      seq.infinite_length = true
-      expected = %w{ A2 80 30 80 13 03 61 62 63 00 00 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, seq.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::PrintableString.new('abc') ,
+                OpenSSL::ASN1::EndOfContent.new() ]
+    seq = OpenSSL::ASN1::Sequence.new(content, 2, :EXPLICIT)
+    seq.infinite_length = true
+    expected = %w{ A2 80 30 80 13 03 61 62 63 00 00 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, seq.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_cons_implicit_tagging
-    begin
-      content = [ OpenSSL::ASN1::Null.new(nil) ]
-      seq = OpenSSL::ASN1::Sequence.new(content, 1, :IMPLICIT)
-      expected = %w{ A1 02 05 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, seq.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::Null.new(nil) ]
+    seq = OpenSSL::ASN1::Sequence.new(content, 1, :IMPLICIT)
+    expected = %w{ A1 02 05 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, seq.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_cons_implicit_tagging_inf_length
-    begin
-      content = [ OpenSSL::ASN1::Null.new(nil),
-                  OpenSSL::ASN1::EndOfContent.new() ]
-      seq = OpenSSL::ASN1::Sequence.new(content, 1, :IMPLICIT)
-      seq.infinite_length = true
-      expected = %w{ A1 80 05 00 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, seq.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::Null.new(nil),
+                OpenSSL::ASN1::EndOfContent.new() ]
+    seq = OpenSSL::ASN1::Sequence.new(content, 1, :IMPLICIT)
+    seq.infinite_length = true
+    expected = %w{ A1 80 05 00 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, seq.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_octet_string_infinite_length_explicit_tagging
-    begin
-      octets = [ OpenSSL::ASN1::OctetString.new('aaa'),
-                 OpenSSL::ASN1::EndOfContent.new() ]
-      cons = OpenSSL::ASN1::Constructive.new(
-        octets,
-        1,
-        :EXPLICIT)
-      cons.infinite_length = true
-      expected = %w{ A1 80 24 80 04 03 61 61 61 00 00 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    octets = [ OpenSSL::ASN1::OctetString.new('aaa'),
+               OpenSSL::ASN1::EndOfContent.new() ]
+    cons = OpenSSL::ASN1::Constructive.new(octets, 1, :EXPLICIT)
+    cons.infinite_length = true
+    expected = %w{ A1 80 24 80 04 03 61 61 61 00 00 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_octet_string_infinite_length_implicit_tagging
-    begin
-      octets = [ OpenSSL::ASN1::OctetString.new('aaa'),
-                 OpenSSL::ASN1::EndOfContent.new() ]
-      cons = OpenSSL::ASN1::Constructive.new(
-        octets,
-        0,
-        :IMPLICIT)
-      cons.infinite_length = true
-      expected = %w{ A0 80 04 03 61 61 61 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    octets = [ OpenSSL::ASN1::OctetString.new('aaa'),
+               OpenSSL::ASN1::EndOfContent.new() ]
+    cons = OpenSSL::ASN1::Constructive.new(octets, 0, :IMPLICIT)
+    cons.infinite_length = true
+    expected = %w{ A0 80 04 03 61 61 61 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_recursive_octet_string_infinite_length
-    begin
-      octets_sub1 = [ OpenSSL::ASN1::OctetString.new("\x01"),
-                      OpenSSL::ASN1::EndOfContent.new() ]
-      octets_sub2 = [ OpenSSL::ASN1::OctetString.new("\x02"),
-                      OpenSSL::ASN1::EndOfContent.new() ]
-      container1 = OpenSSL::ASN1::Constructive.new(
-        octets_sub1,
-        OpenSSL::ASN1::OCTET_STRING,
-        nil,
-        :UNIVERSAL)
-      container1.infinite_length = true
-      container2 = OpenSSL::ASN1::Constructive.new(
-        octets_sub2,
-        OpenSSL::ASN1::OCTET_STRING,
-        nil,
-        :UNIVERSAL)
-      container2.infinite_length = true
-      octets3 = OpenSSL::ASN1::OctetString.new("\x03")
-
-      octets = [ container1, container2, octets3,
-                 OpenSSL::ASN1::EndOfContent.new() ]
-      cons = OpenSSL::ASN1::Constructive.new(
-        octets,
-        OpenSSL::ASN1::OCTET_STRING,
-        nil,
-        :UNIVERSAL)
-      cons.infinite_length = true
-      expected = %w{ 24 80 24 80 04 01 01 00 00 24 80 04 01 02 00 00 04 01 03 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    octets_sub1 = [ OpenSSL::ASN1::OctetString.new("\x01"),
+                    OpenSSL::ASN1::EndOfContent.new() ]
+    octets_sub2 = [ OpenSSL::ASN1::OctetString.new("\x02"),
+                    OpenSSL::ASN1::EndOfContent.new() ]
+    container1 = OpenSSL::ASN1::Constructive.new(octets_sub1, OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
+    container1.infinite_length = true
+    container2 = OpenSSL::ASN1::Constructive.new(octets_sub2, OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
+    container2.infinite_length = true
+    octets3 = OpenSSL::ASN1::OctetString.new("\x03")
+
+    octets = [ container1, container2, octets3,
+               OpenSSL::ASN1::EndOfContent.new() ]
+    cons = OpenSSL::ASN1::Constructive.new(octets, OpenSSL::ASN1::OCTET_STRING, nil, :UNIVERSAL)
+    cons.infinite_length = true
+    expected = %w{ 24 80 24 80 04 01 01 00 00 24 80 04 01 02 00 00 04 01 03 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_bit_string_infinite_length
-    begin
-      content = [ OpenSSL::ASN1::BitString.new("\x01"),
-                  OpenSSL::ASN1::EndOfContent.new() ]
-      cons = OpenSSL::ASN1::Constructive.new(
-        content,
-        OpenSSL::ASN1::BIT_STRING,
-        nil,
-        :UNIVERSAL)
-      cons.infinite_length = true
-      expected = %w{ 23 80 03 02 00 01 00 00 }
-      raw = [expected.join('')].pack('H*')
-      assert_equal(raw, cons.to_der)
-      assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
-    end
+    content = [ OpenSSL::ASN1::BitString.new("\x01"),
+                OpenSSL::ASN1::EndOfContent.new() ]
+    cons = OpenSSL::ASN1::Constructive.new(content, OpenSSL::ASN1::BIT_STRING, nil, :UNIVERSAL)
+    cons.infinite_length = true
+    expected = %w{ 23 80 03 02 00 01 00 00 }
+    raw = [expected.join('')].pack('H*')
+    assert_equal(raw, cons.to_der)
+    assert_equal(raw, OpenSSL::ASN1.decode(raw).to_der)
   end
 
   def test_primitive_inf_length
@@ -621,4 +546,3 @@ rEzBQ0F9dUyqQ9gyRg8KHhDfv9HzT1d/rnUZMkoombwYBRIUChGCYV0GnJcan2Zm
   end
 
 end if defined?(OpenSSL::TestUtils)
-
-- 
cgit v1.2.3