Module: TypeStructTest

Defined in:
lib/type_struct_test.rb

Defined Under Namespace

Classes: Dummy, Sample

Instance Method Summary collapse

Instance Method Details

#example_readme ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/type_struct_test.rb', line 113

def example_readme
  sample = Sample.new(
    str: "instance of String",
    reg: "not match to regexp",
    num: 10,
    any: true,
  )
  p sample
  p sample.to_h
  # Output:
  # #<TypeStructTest::Sample str="instance of String", reg="not match to regexp", num=10, any=true>
  # {:str=>"instance of String", :reg=>"not match to regexp", :num=>10, :any=>true}
end

#test_getter(t) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/type_struct_test.rb', line 74

def test_getter(t)
  dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", any: [1, "bbb"])
  _, err = go { dummy[:str] }
  if err != nil
    t.error("expect not raise error when valid value get. got #{err}")
  end
  _, err = go { dummy[:nothing] }
  if err == nil
    t.error("expect not raise error when invalid value get")
  end
end

#test_initialize(t) ⇒ Object 



40
41
42
43
44
45
46
47
48
 
# File 'lib/type_struct_test.rb', line 40

def test_initialize(t)
  expects = {str: "aaa", num: 123, reg: "abc", any: [1, "bbb"]}
  dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", any: [1, "bbb"])
  expects.each do |k, v|
    unless dummy[k] == v
      t.error("expect #{dummy[k]} got #{v}")
    end
  end
end

#test_initialize_invalid_type(t) ⇒ Object 



57
58
59
60
61
62
 
# File 'lib/type_struct_test.rb', line 57

def test_initialize_invalid_type(t)
  value, err = go { Dummy.new(str: "aaa", num: 123, reg: "abb", any: nil) }
  if err == nil
    t.error("invalid value expect raise error")
  end
end

#test_initialize_not_enough(t) ⇒ Object 



50
51
52
53
54
55
 
# File 'lib/type_struct_test.rb', line 50

def test_initialize_not_enough(t)
  _, err = go { Dummy.new(str: "aaa") }
  if err == nil
    t.error("in initialize, expect raise error since not enough members but nothing raised")
  end
end

#test_s_members(t) ⇒ Object 



11
12
13
14
15
16
17
 
# File 'lib/type_struct_test.rb', line 11

def test_s_members(t)
  m = Dummy.members
  expect = {str: String, num: Integer, reg: /abc/, any: Object}
  unless m == expect
    t.error("expect #{expect} got #{m}")
  end
end

#test_s_type(t) ⇒ Object 



19
20
21
22
23
24
25
26
 
# File 'lib/type_struct_test.rb', line 19

def test_s_type(t)
  m = Dummy.members
  m.each do |k, v|
    unless Dummy.type(k) == v
      t.error("expect #{v} got #{Dummy.type(k)}")
    end
  end
end

#test_s_valid?(t) ⇒ Boolean

Returns:

  • (Boolean) 


28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/type_struct_test.rb', line 28

def test_s_valid?(t)
  unless Dummy.valid?(:str, "abc")
    t.error('expect :str valid "abc"')
  end
  if Dummy.valid?(:str, 345)
    t.error("expect :str invalid 345")
  end
  unless Dummy.valid?(:reg, "abc")
    t.error('expect :reg valid "abc"')
  end
end

#test_setter(t) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/type_struct_test.rb', line 86

def test_setter(t)
  dummy = Dummy.new(str: "aaa", num: 123, reg: "abc", any: [1, "bbb"])
  i(str num reg).each do |k, v|
    _, err = go { dummy[k] = nil }
    if err == nil
      t.error("expect raise error when invalid value set")
    end
  end

  _, err = go { dummy[:any] = nil }
  if err != nil
    t.error("expect not raise error when valid value set got #{err}")
  end

  _, err = go { dummy[:nothing] = nil }
  if err == nil
    t.error("expect not raise error when valid value set got #{err}")
  end
end

#test_to_h(t) ⇒ Object 



64
65
66
67
68
69
70
71
72
 
# File 'lib/type_struct_test.rb', line 64

def test_to_h(t)
  expects = {str: "aaa", num: 123, reg: "abcde", any: [1, "bbb"]}
  dummy = Dummy.new(str: "aaa", num: 123, reg: "abcde", any: [1, "bbb"])
  expects.each do |k, v|
    unless dummy[k] == v
      t.error("expect #{dummy[k]} got #{v}")
    end
  end
end