luruju 0.0.1
Sign up to get free protection for your applications and to get access to all the features.
- data/LICENSE +23 -0
- data/Rakefile +84 -0
- data/lib/luruju/add_useful_method.rb +36 -0
- data/lib/luruju/dynamic_method.rb +22 -0
- data/lib/luruju/jude_api.rb +134 -0
- data/lib/luruju/version.rb +8 -0
- data/lib/luruju.rb +11 -0
- data/test/abstract_unit.rb +21 -0
- data/test/jude/model001.jude +0 -0
- data/test/jude/model002.jude +0 -0
- data/test/jude/model003.jude +0 -0
- data/test/jude/model004.jude +0 -0
- data/test/jude/model005.jude +0 -0
- data/test/jude/model006.jude +0 -0
- data/test/jude/model007.jude +0 -0
- data/test/jude/model008.jude +0 -0
- data/test/jude/model009.jude +0 -0
- data/test/jude/model010.jude +0 -0
- data/test/jude/model011.jude +0 -0
- data/test/jude/model012.jude +0 -0
- data/test/jude/model013.jude +0 -0
- data/test/jude/model013.jude.bak +0 -0
- data/test/jude_api_test.rb +578 -0
- metadata +73 -0
data/LICENSE
ADDED
@@ -0,0 +1,23 @@
|
|
1
|
+
== MIT License
|
2
|
+
|
3
|
+
Copyright (c) 2007, Shuhei Nomura
|
4
|
+
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining
|
6
|
+
a copy of this software and associated documentation files (the
|
7
|
+
"Software"), to deal in the Software without restriction, including
|
8
|
+
without limitation the rights to use, copy, modify, merge, publish,
|
9
|
+
distribute, sublicense, and/or sell copies of the Software, and to
|
10
|
+
permit persons to whom the Software is furnished to do so, subject to
|
11
|
+
the following conditions:
|
12
|
+
|
13
|
+
The above copyright notice and this permission notice shall be
|
14
|
+
included in all copies or substantial portions of the Software.
|
15
|
+
|
16
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
17
|
+
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
18
|
+
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
19
|
+
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
20
|
+
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
21
|
+
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
22
|
+
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
23
|
+
|
data/Rakefile
ADDED
@@ -0,0 +1,84 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'rake'
|
3
|
+
require 'rake/testtask'
|
4
|
+
# TODO require 'rake/rdoctask'
|
5
|
+
require 'rake/packagetask'
|
6
|
+
require 'rake/gempackagetask'
|
7
|
+
# TODO require 'rake/contrib/rubyforgepublisher'
|
8
|
+
require File.join(File.dirname(__FILE__), 'lib', 'luruju', 'version')
|
9
|
+
|
10
|
+
PKG_BUILD = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
|
11
|
+
PKG_NAME = 'luruju'
|
12
|
+
PKG_VERSION = Luruju::VERSION::STRING + PKG_BUILD
|
13
|
+
PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
|
14
|
+
|
15
|
+
|
16
|
+
Rake::TestTask.new('test') do |t|
|
17
|
+
t.libs << "test"
|
18
|
+
t.pattern = "test/**/*_test.rb"
|
19
|
+
# t.warning = true
|
20
|
+
end
|
21
|
+
|
22
|
+
# Create compressed packages
|
23
|
+
dist_dirs = [ "lib", "test" ]
|
24
|
+
|
25
|
+
spec = Gem::Specification.new do |s|
|
26
|
+
s.platform = Gem::Platform::RUBY
|
27
|
+
s.name = PKG_NAME
|
28
|
+
s.version = PKG_VERSION
|
29
|
+
s.summary = "A library for coordinating with Ruby And JUDE."
|
30
|
+
# TODO s.description = %q{}
|
31
|
+
|
32
|
+
s.author = "Shuhei Nomura"
|
33
|
+
# TODO s.email = "david@loudthinking.com"
|
34
|
+
s.rubyforge_project = PKG_NAME
|
35
|
+
s.homepage = "http://luruju.com"
|
36
|
+
|
37
|
+
s.has_rdoc = false # TODO
|
38
|
+
# TODO s.extra_rdoc_files = ["README"]
|
39
|
+
s.requirements << 'JUDE Community'
|
40
|
+
|
41
|
+
s.add_dependency('activesupport', '= 1.4.2' + PKG_BUILD)
|
42
|
+
|
43
|
+
s.require_path = 'lib'
|
44
|
+
s.autorequire = 'luruju'
|
45
|
+
|
46
|
+
|
47
|
+
s.files = [ "LICENSE", "Rakefile"]
|
48
|
+
# TODO s.files << "CHANGELOG"
|
49
|
+
# TODO s.files << "README"
|
50
|
+
dist_dirs.each do |dir|
|
51
|
+
s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |i| (/^\.svn/ =~ i) or (/\~\z/) =~ i }
|
52
|
+
end
|
53
|
+
|
54
|
+
end
|
55
|
+
|
56
|
+
Rake::GemPackageTask.new(spec) do |p|
|
57
|
+
p.gem_spec = spec
|
58
|
+
p.need_tar = true
|
59
|
+
p.need_zip = true
|
60
|
+
end
|
61
|
+
|
62
|
+
task :lines do
|
63
|
+
lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
|
64
|
+
|
65
|
+
for file_name in FileList["lib/**/*.rb"]
|
66
|
+
next if file_name =~ /vendor/
|
67
|
+
f = File.open(file_name)
|
68
|
+
|
69
|
+
while line = f.gets
|
70
|
+
lines += 1
|
71
|
+
next if line =~ /^\s*$/
|
72
|
+
next if line =~ /^\s*#/
|
73
|
+
codelines += 1
|
74
|
+
end
|
75
|
+
puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
|
76
|
+
|
77
|
+
total_lines += lines
|
78
|
+
total_codelines += codelines
|
79
|
+
|
80
|
+
lines, codelines = 0, 0
|
81
|
+
end
|
82
|
+
|
83
|
+
puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
|
84
|
+
end
|
@@ -0,0 +1,36 @@
|
|
1
|
+
|
2
|
+
module Luruju
|
3
|
+
|
4
|
+
module JudeApi
|
5
|
+
|
6
|
+
class JudeBase
|
7
|
+
|
8
|
+
include DynamicMethod
|
9
|
+
|
10
|
+
def dyna_01_select_XXXs_by_YYY(method, *args)
|
11
|
+
raise IsNotMyRole unless /^(find_all|select)_(.+?)_by_(.+?)$/ =~ method.to_s
|
12
|
+
a_getter, attr, param = $2, $3, args[0]
|
13
|
+
raise IsNotMyRole unless self.class.method_defined?(a_getter)
|
14
|
+
ope = param.instance_of?(Regexp) ? "=~" : "=="
|
15
|
+
instance_eval("#{a_getter}.select{|i|i.#{attr} #{ope} param}");
|
16
|
+
end
|
17
|
+
|
18
|
+
def dyna_02_find_XXX_by_YYY(method, *args)
|
19
|
+
raise IsNotMyRole unless /^find_(.+?)_by_(.+?)$/ =~ method.to_s
|
20
|
+
clazz, attr, param = $1, $2, args[0]
|
21
|
+
a_getter = Inflector.pluralize(clazz)
|
22
|
+
ope = param.instance_of?(Regexp) ? "=~" : "=="
|
23
|
+
instance_eval("#{a_getter}.find{|i|i.#{attr} #{ope} param}");
|
24
|
+
end
|
25
|
+
|
26
|
+
def dyna_children_access(method, *args)
|
27
|
+
raise IsNotMyRole unless self.class.method_defined?(:owned_elements)
|
28
|
+
api_name = "Jude" + Inflector.classify(method.to_s)
|
29
|
+
raise IsNotMyRole unless JudeApi.constants.include?(api_name)
|
30
|
+
owned_elements.select{|p| p.instance_of?(JudeApi.module_eval(api_name))}
|
31
|
+
end
|
32
|
+
|
33
|
+
end
|
34
|
+
end
|
35
|
+
|
36
|
+
end
|
@@ -0,0 +1,22 @@
|
|
1
|
+
|
2
|
+
|
3
|
+
module Luruju
|
4
|
+
|
5
|
+
module DynamicMethod
|
6
|
+
|
7
|
+
class IsNotMyRole < StandardError
|
8
|
+
end
|
9
|
+
|
10
|
+
def method_missing(method, *args)
|
11
|
+
method_name = method.to_s
|
12
|
+
methods.select{|m|/^dyna_.*/ =~ m.to_s}.sort.each { |dyna_method|
|
13
|
+
begin
|
14
|
+
return send(dyna_method, method, *args)
|
15
|
+
rescue IsNotMyRole
|
16
|
+
end
|
17
|
+
}
|
18
|
+
super
|
19
|
+
end
|
20
|
+
|
21
|
+
end
|
22
|
+
end
|
@@ -0,0 +1,134 @@
|
|
1
|
+
|
2
|
+
require 'java'
|
3
|
+
|
4
|
+
module Luruju
|
5
|
+
|
6
|
+
JUDEAPI_PHEAD = 'com.change_vision.jude.api.inf'
|
7
|
+
|
8
|
+
class JudeApiLoader
|
9
|
+
|
10
|
+
include_class("#{JUDEAPI_PHEAD}.project.ProjectAccessorFactory")
|
11
|
+
|
12
|
+
def self.load(jude_file)
|
13
|
+
project_accessor = ProjectAccessorFactory.getProjectAccessor
|
14
|
+
begin
|
15
|
+
project_accessor.open(jude_file)
|
16
|
+
getter = project_accessor.getClass.getDeclaredMethod("getProject", nil)
|
17
|
+
return JudeApiBuilder.new.build(project_accessor, getter)
|
18
|
+
ensure
|
19
|
+
project_accessor.close
|
20
|
+
end
|
21
|
+
end
|
22
|
+
end
|
23
|
+
|
24
|
+
class JudeApiBuilder
|
25
|
+
|
26
|
+
CLASS_DEFAULT_METHODS = Class.methods.clone
|
27
|
+
|
28
|
+
def initialize
|
29
|
+
@already_builded = Hash.new
|
30
|
+
end
|
31
|
+
|
32
|
+
def build(java_parent, java_getter)
|
33
|
+
begin
|
34
|
+
java_obj = java_parent.send(java_getter.getName)
|
35
|
+
rescue NativeException => e
|
36
|
+
# p "Warning(#{__FILE__},#{__LINE__}) " + java_getter.getName
|
37
|
+
end
|
38
|
+
|
39
|
+
return nil if java_obj == nil
|
40
|
+
|
41
|
+
java_return_class = java_getter.getReturnType
|
42
|
+
|
43
|
+
if is_jude_class?(java_return_class)
|
44
|
+
return build_judeapi(java_obj, java_return_class)
|
45
|
+
elsif java_return_class.isArray
|
46
|
+
return build_array(java_obj, java_getter)
|
47
|
+
else
|
48
|
+
return java_obj
|
49
|
+
end
|
50
|
+
end
|
51
|
+
|
52
|
+
def build_array(java_obj, java_getter)
|
53
|
+
|
54
|
+
comp_type = java_getter.getReturnType.getComponentType
|
55
|
+
|
56
|
+
if is_jude_class?(comp_type)
|
57
|
+
jude_objects = Array.new
|
58
|
+
java_obj.each {|i| jude_objects << build_judeapi(i, comp_type) }
|
59
|
+
return jude_objects
|
60
|
+
else
|
61
|
+
return java_obj.to_a
|
62
|
+
end
|
63
|
+
end
|
64
|
+
|
65
|
+
def build_judeapi(jude_obj, jude_class)
|
66
|
+
|
67
|
+
if is_jude_named_element?(jude_obj) and @already_builded.key?(jude_obj.getId)
|
68
|
+
return @already_builded[jude_obj.getId]
|
69
|
+
end
|
70
|
+
|
71
|
+
raise "UnExpected." + jude_obj.getClass if jude_obj.getClass.getInterfaces.length > 1
|
72
|
+
|
73
|
+
interface = jude_obj.getClass.getInterfaces[0]
|
74
|
+
judeapi_class = define_judeapi_class(interface)
|
75
|
+
judeapi_obj = judeapi_class.new
|
76
|
+
|
77
|
+
@already_builded[jude_obj.getId] = judeapi_obj if is_jude_named_element?(jude_obj)
|
78
|
+
|
79
|
+
interface.getMethods.each { |java_method|
|
80
|
+
setter_name = define_judeapi_method(judeapi_class, java_method)
|
81
|
+
judeapi_obj.send(setter_name, build(jude_obj, java_method))
|
82
|
+
}
|
83
|
+
return judeapi_obj
|
84
|
+
end
|
85
|
+
|
86
|
+
def define_judeapi_method(judeapi_class, java_method)
|
87
|
+
|
88
|
+
java_method_name = java_method.getName
|
89
|
+
attr_name =java_method_name.sub(/^(get)/,'')
|
90
|
+
attr_name = Inflector.underscore(attr_name)
|
91
|
+
getter_name = attr_name.clone
|
92
|
+
getter_name << "?" if java_method_name.match(/^is/)
|
93
|
+
setter_name = attr_name + "="
|
94
|
+
return setter_name if judeapi_class.method_defined?(setter_name)
|
95
|
+
|
96
|
+
statement = String.new
|
97
|
+
statement << "def #{getter_name}() @#{attr_name} end\n"
|
98
|
+
statement << "def #{setter_name}(#{attr_name}) @#{attr_name}=#{attr_name} end\n"
|
99
|
+
judeapi_class.class_eval(statement)
|
100
|
+
return setter_name
|
101
|
+
|
102
|
+
end
|
103
|
+
|
104
|
+
def is_jude_class?(java_class)
|
105
|
+
java_class.getName.index(JUDEAPI_PHEAD) == 0
|
106
|
+
end
|
107
|
+
|
108
|
+
def is_jude_named_element?(jude_obj)
|
109
|
+
jude_obj.getClass.getMethod("getId", nil)
|
110
|
+
return true
|
111
|
+
rescue java.lang.NoSuchMethodException =>e
|
112
|
+
return false
|
113
|
+
end
|
114
|
+
|
115
|
+
def define_judeapi_class(java_class)
|
116
|
+
java_class_name = java_class.getSimpleName
|
117
|
+
judeapi_class_name = "Jude" + java_class_name.sub(/^I/,'')
|
118
|
+
if JudeApi.const_defined?(judeapi_class_name)
|
119
|
+
return JudeApi.module_eval(judeapi_class_name)
|
120
|
+
end
|
121
|
+
|
122
|
+
JudeApi.module_eval("class #{judeapi_class_name} < JudeBase ; end")
|
123
|
+
judeapi_class = JudeApi.module_eval(judeapi_class_name)
|
124
|
+
java_class.getDeclaredFields.each do |p|
|
125
|
+
const_name = p.getName
|
126
|
+
const_value = p.get(nil)
|
127
|
+
judeapi_class.class_eval("#{const_name} = #{const_value}")
|
128
|
+
end
|
129
|
+
return judeapi_class
|
130
|
+
end
|
131
|
+
|
132
|
+
end
|
133
|
+
|
134
|
+
end
|
data/lib/luruju.rb
ADDED
@@ -0,0 +1,21 @@
|
|
1
|
+
$:.unshift(File.dirname(__FILE__) + '/../lib')
|
2
|
+
|
3
|
+
require 'test/unit'
|
4
|
+
require 'luruju'
|
5
|
+
|
6
|
+
class Test::Unit::TestCase
|
7
|
+
|
8
|
+
TEST_JUDE_DIR = File.dirname(__FILE__) + '/jude'
|
9
|
+
|
10
|
+
include Luruju
|
11
|
+
|
12
|
+
def setup
|
13
|
+
# JudeApi.constants.each {|c| JudeApi.remove_const(c)}
|
14
|
+
end
|
15
|
+
|
16
|
+
protected
|
17
|
+
def jude_api_load(jude_file)
|
18
|
+
Luruju::JudeApiLoader.load("#{TEST_JUDE_DIR}/#{jude_file}.jude")
|
19
|
+
end
|
20
|
+
|
21
|
+
end
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
Binary file
|
@@ -0,0 +1,578 @@
|
|
1
|
+
$:.unshift(File.dirname(__FILE__))
|
2
|
+
require 'abstract_unit'
|
3
|
+
|
4
|
+
|
5
|
+
class JudeTest < Test::Unit::TestCase
|
6
|
+
|
7
|
+
def setup
|
8
|
+
super
|
9
|
+
end
|
10
|
+
|
11
|
+
def test_model001_check_class_api
|
12
|
+
|
13
|
+
jude_project = jude_api_load("model001")
|
14
|
+
assert(jude_project.instance_of?(JudeApi::JudeModel))
|
15
|
+
assert(jude_project.id != nil)
|
16
|
+
assert_equal("model001", jude_project.name)
|
17
|
+
|
18
|
+
human_class = jude_project.find_class_by_name("Human")
|
19
|
+
animal_class = jude_project.find_class_by_name("Animal")
|
20
|
+
programmer_if = jude_project.find_class_by_name("IProgrammer")
|
21
|
+
|
22
|
+
assert(human_class.instance_of?(JudeApi::JudeClass))
|
23
|
+
|
24
|
+
#IElement
|
25
|
+
assert(human_class.id)
|
26
|
+
assert_same(jude_project, human_class.owner)
|
27
|
+
assert_equal(0, human_class.comments.size)
|
28
|
+
assert_equal(2, human_class.stereotypes.size)
|
29
|
+
assert_equal("stereotype1", human_class.stereotypes[0])
|
30
|
+
assert_equal("stereotype2", human_class.stereotypes[1])
|
31
|
+
assert_equal(0, human_class.tagged_values.size)
|
32
|
+
|
33
|
+
#INamedElement
|
34
|
+
assert_equal("Human", human_class.name)
|
35
|
+
assert_equal(0, human_class.constraints.size)
|
36
|
+
assert_equal(0, human_class.comments.size)
|
37
|
+
assert_equal(0, human_class.supplier_dependencies.size)
|
38
|
+
assert_equal(0, human_class.client_dependencies.size)
|
39
|
+
assert_equal("ClassDefinition", human_class.definition)
|
40
|
+
|
41
|
+
assert_equal(true, human_class.is_public_visibility?)
|
42
|
+
assert_equal(false, human_class.is_protected_visibility?)
|
43
|
+
assert_equal(false, human_class.is_private_visibility?)
|
44
|
+
assert_equal(false, human_class.is_package_visibility?)
|
45
|
+
|
46
|
+
assert_equal(false, animal_class.is_public_visibility?)
|
47
|
+
assert_equal(true, animal_class.is_protected_visibility?)
|
48
|
+
assert_equal(false, animal_class.is_private_visibility?)
|
49
|
+
assert_equal(false, animal_class.is_package_visibility?)
|
50
|
+
|
51
|
+
assert_equal(0, human_class.diagrams.size)
|
52
|
+
|
53
|
+
#IClass
|
54
|
+
assert_equal(false, human_class.is_abstract?)
|
55
|
+
assert_equal(true, animal_class.is_abstract?)
|
56
|
+
assert_equal(true, human_class.is_leaf?)
|
57
|
+
assert_equal(false, animal_class.is_leaf?)
|
58
|
+
assert_equal(false, human_class.is_active?)
|
59
|
+
assert_equal(true, animal_class.is_active?)
|
60
|
+
assert_equal(4, human_class.attributes.size)
|
61
|
+
assert_equal(1, human_class.select_attributes_by_name("attr1").size)
|
62
|
+
assert_equal(1, human_class.select_attributes_by_name("attr2").size)
|
63
|
+
assert_equal(1, human_class.select_attributes_by_name("has-car").size)
|
64
|
+
assert_equal(1, human_class.select_attributes_by_name("has-pc").size)
|
65
|
+
assert_equal(2, human_class.operations.size)
|
66
|
+
assert_equal(1, human_class.select_operations_by_name("ope1").size)
|
67
|
+
assert_equal(1, human_class.select_operations_by_name("ope2").size)
|
68
|
+
assert_equal(0, human_class.nested_classes.size)
|
69
|
+
assert_equal(2, human_class.generalizations.size)
|
70
|
+
assert_equal("Animal-Human", human_class.generalizations[0].name)
|
71
|
+
assert_equal("Dream-Human", human_class.generalizations[1].name)
|
72
|
+
assert_equal(0, human_class.specializations.size)
|
73
|
+
assert_equal(2, animal_class.specializations.size)
|
74
|
+
assert_equal("Animal-Human", animal_class.specializations[0].name)
|
75
|
+
assert_equal("Animal-Dog", animal_class.specializations[1].name)
|
76
|
+
assert_equal(0, human_class.supplier_realizations.size)
|
77
|
+
assert_equal(2, programmer_if.supplier_realizations.size)
|
78
|
+
assert_equal("IProgrammer-Human", programmer_if.supplier_realizations[0].name)
|
79
|
+
assert_equal("IProgrammer-Dog", programmer_if.supplier_realizations[1].name)
|
80
|
+
assert_equal(2, human_class.client_realizations.size)
|
81
|
+
assert_equal("IProgrammer-Human", human_class.client_realizations[0].name)
|
82
|
+
assert_equal("IDriver-Human", human_class.client_realizations[1].name)
|
83
|
+
|
84
|
+
end
|
85
|
+
|
86
|
+
def test_model002_check_attribute_api
|
87
|
+
|
88
|
+
jude_project = jude_api_load("model002")
|
89
|
+
human_class = jude_project.find_class_by_name("Human")
|
90
|
+
name_attr = human_class.find_attribute_by_name("name")
|
91
|
+
age_attr = human_class.find_attribute_by_name("age")
|
92
|
+
weight_attr = human_class.find_attribute_by_name("weight")
|
93
|
+
from_attr = human_class.find_attribute_by_name("from")
|
94
|
+
car_attr = human_class.find_attributes_by_name("has-car")
|
95
|
+
assert(name_attr.instance_of?(JudeApi::JudeAttribute))
|
96
|
+
|
97
|
+
#IElement
|
98
|
+
assert(name_attr.id)
|
99
|
+
assert_same(human_class, name_attr.owner)
|
100
|
+
assert_equal(0, name_attr.comments.size)
|
101
|
+
assert_equal(2, name_attr.stereotypes.size)
|
102
|
+
assert_equal("stereotype1", name_attr.stereotypes[0])
|
103
|
+
assert_equal("stereotype2", name_attr.stereotypes[1])
|
104
|
+
assert_equal(0, name_attr.tagged_values.size)
|
105
|
+
|
106
|
+
# NamedElement
|
107
|
+
assert_equal("name", name_attr.name)
|
108
|
+
assert_equal(2, name_attr.constraints.size)
|
109
|
+
assert_equal("constraint1", name_attr.constraints[0].name)
|
110
|
+
assert_equal("constraint2", name_attr.constraints[1].name)
|
111
|
+
assert_equal(0, name_attr.comments.size)
|
112
|
+
assert_equal(0, name_attr.supplier_dependencies.size)
|
113
|
+
assert_equal(0, name_attr.client_dependencies.size)
|
114
|
+
assert_equal("AttributeDefinition", name_attr.definition)
|
115
|
+
|
116
|
+
assert_equal(true, name_attr.is_private_visibility?)
|
117
|
+
assert_equal(false, name_attr.is_package_visibility?)
|
118
|
+
assert_equal(false, name_attr.is_protected_visibility?)
|
119
|
+
assert_equal(false, name_attr.is_public_visibility?)
|
120
|
+
|
121
|
+
assert_equal(false, age_attr.is_private_visibility?)
|
122
|
+
assert_equal(true, age_attr.is_package_visibility?)
|
123
|
+
assert_equal(false, age_attr.is_protected_visibility?)
|
124
|
+
assert_equal(false, age_attr.is_public_visibility?)
|
125
|
+
|
126
|
+
assert_equal(false, weight_attr.is_private_visibility?)
|
127
|
+
assert_equal(false, weight_attr.is_package_visibility?)
|
128
|
+
assert_equal(true, weight_attr.is_protected_visibility?)
|
129
|
+
assert_equal(false, weight_attr.is_public_visibility?)
|
130
|
+
|
131
|
+
assert_equal(false, from_attr.is_private_visibility?)
|
132
|
+
assert_equal(false, from_attr.is_package_visibility?)
|
133
|
+
assert_equal(false, from_attr.is_protected_visibility?)
|
134
|
+
assert_equal(true, from_attr.is_public_visibility?)
|
135
|
+
|
136
|
+
assert_equal(0, name_attr.diagrams.size)
|
137
|
+
|
138
|
+
#IAttribute
|
139
|
+
assert_equal("String", name_attr.type.name)
|
140
|
+
assert_equal("String", name_attr.type_expression)
|
141
|
+
assert_equal("", name_attr.initial_value)
|
142
|
+
assert_equal("0", age_attr.initial_value)
|
143
|
+
assert_equal(true, name_attr.is_changeable?)
|
144
|
+
assert_equal(false, weight_attr.is_changeable?)
|
145
|
+
assert_equal(nil, name_attr.association)
|
146
|
+
assert_equal("Human-has-Car", car_attr.association.name)
|
147
|
+
assert_equal(0, name_attr.qualifiers.size) # TODO qualifierは何者?
|
148
|
+
assert_equal(0, name_attr.multiplicity.size)
|
149
|
+
assert_equal(1, car_attr.multiplicity.size)
|
150
|
+
assert_equal(false, name_attr.is_derived?)
|
151
|
+
assert_equal(true, from_attr.is_derived?)
|
152
|
+
assert_equal(false, name_attr.is_composite?)
|
153
|
+
# TODO 本当はtrue
|
154
|
+
#assert_equal(true, weight_attr.is_composite?)
|
155
|
+
assert_equal(false, name_attr.is_aggregate?)
|
156
|
+
# TODO 本当はtrue
|
157
|
+
#assert_equal(true, age_attr.is_aggregate?)
|
158
|
+
assert_equal(true, name_attr.is_enable?)
|
159
|
+
assert_equal(false, name_attr.is_static?)
|
160
|
+
assert_equal(true, age_attr.is_static?)
|
161
|
+
end
|
162
|
+
|
163
|
+
def test_model003_check_opperation_api
|
164
|
+
|
165
|
+
jude_project = jude_api_load("model003")
|
166
|
+
human_class = jude_project.find_class_by_name("Human")
|
167
|
+
assert_equal 4, human_class.operations.size
|
168
|
+
eat_ope = human_class.find_operation_by_name("eat")
|
169
|
+
drink_ope = human_class.find_operation_by_name("drink")
|
170
|
+
work_ope = human_class.find_operation_by_name("work")
|
171
|
+
play_ope = human_class.find_operation_by_name("play")
|
172
|
+
assert(eat_ope.instance_of?(JudeApi::JudeOperation))
|
173
|
+
|
174
|
+
#IElement
|
175
|
+
assert(eat_ope.id)
|
176
|
+
assert_same(human_class, eat_ope.owner)
|
177
|
+
assert_equal(0, eat_ope.comments.size)
|
178
|
+
assert_equal(2, eat_ope.stereotypes.size)
|
179
|
+
assert_equal("stereotype1", eat_ope.stereotypes[0])
|
180
|
+
assert_equal("stereotype2", eat_ope.stereotypes[1])
|
181
|
+
assert_equal(0, eat_ope.tagged_values.size)
|
182
|
+
|
183
|
+
# NamedElement
|
184
|
+
assert_equal("eat", eat_ope.name)
|
185
|
+
assert_equal(2, eat_ope.constraints.size)
|
186
|
+
assert_equal("constraint1", eat_ope.constraints[0].name)
|
187
|
+
assert_equal("constraint2", eat_ope.constraints[1].name)
|
188
|
+
assert_equal(0, eat_ope.comments.size)
|
189
|
+
assert_equal(0, eat_ope.supplier_dependencies.size)
|
190
|
+
assert_equal(0, eat_ope.client_dependencies.size)
|
191
|
+
assert_equal("OperationDefinition", eat_ope.definition)
|
192
|
+
|
193
|
+
assert_equal(false, eat_ope.is_private_visibility?)
|
194
|
+
assert_equal(false, eat_ope.is_package_visibility?)
|
195
|
+
assert_equal(false, eat_ope.is_protected_visibility?)
|
196
|
+
assert_equal(true, eat_ope.is_public_visibility?)
|
197
|
+
|
198
|
+
assert_equal(false, drink_ope.is_private_visibility?)
|
199
|
+
assert_equal(false, drink_ope.is_package_visibility?)
|
200
|
+
assert_equal(true, drink_ope.is_protected_visibility?)
|
201
|
+
assert_equal(false, drink_ope.is_public_visibility?)
|
202
|
+
|
203
|
+
assert_equal(false, work_ope.is_private_visibility?)
|
204
|
+
assert_equal(true, work_ope.is_package_visibility?)
|
205
|
+
assert_equal(false, work_ope.is_protected_visibility?)
|
206
|
+
assert_equal(false, work_ope.is_public_visibility?)
|
207
|
+
|
208
|
+
assert_equal(true, play_ope.is_private_visibility?)
|
209
|
+
assert_equal(false, play_ope.is_package_visibility?)
|
210
|
+
assert_equal(false, play_ope.is_protected_visibility?)
|
211
|
+
assert_equal(false, play_ope.is_public_visibility?)
|
212
|
+
|
213
|
+
assert_equal(0, eat_ope.diagrams.size)
|
214
|
+
|
215
|
+
#IOperation
|
216
|
+
assert_equal(0, eat_ope.parameters.size)
|
217
|
+
assert_equal(2, drink_ope.parameters.size)
|
218
|
+
assert_equal("param0", drink_ope.parameters[0].name)
|
219
|
+
assert_equal("param1", drink_ope.parameters[1].name)
|
220
|
+
assert_equal("void", eat_ope.return_type.name)
|
221
|
+
assert_equal("int", drink_ope.return_type.name)
|
222
|
+
assert_equal("String", work_ope.return_type.name)
|
223
|
+
assert_equal("void", eat_ope.return_type_expression)
|
224
|
+
assert_equal("int", drink_ope.return_type_expression)
|
225
|
+
assert_equal("String", work_ope.return_type_expression)
|
226
|
+
assert_equal(false, eat_ope.is_leaf?)
|
227
|
+
assert_equal(true, play_ope.is_leaf?)
|
228
|
+
assert_equal(false, eat_ope.is_abstract?)
|
229
|
+
assert_equal(true, work_ope.is_abstract?)
|
230
|
+
assert_equal(false, eat_ope.is_static?)
|
231
|
+
assert_equal(true, drink_ope.is_static?)
|
232
|
+
|
233
|
+
end
|
234
|
+
|
235
|
+
def test_model003_check_parameter_api
|
236
|
+
|
237
|
+
jude_project = jude_api_load("model003")
|
238
|
+
human_class = jude_project.find_class_by_name("Human")
|
239
|
+
string_class = jude_project.find_class_by_name("String")
|
240
|
+
drink_ope = human_class.find_operation_by_name("drink")
|
241
|
+
param1_param = drink_ope.parameters[0]
|
242
|
+
param2_param = drink_ope.parameters[1]
|
243
|
+
assert(param1_param.instance_of?(JudeApi::JudeParameter))
|
244
|
+
assert_equal("int", param1_param.type.name)
|
245
|
+
assert_equal(string_class, param2_param.type)
|
246
|
+
assert_equal("int", param1_param.type_expression)
|
247
|
+
assert_equal("String", param2_param.type_expression)
|
248
|
+
|
249
|
+
end
|
250
|
+
|
251
|
+
def test_model04_check_constraint_api
|
252
|
+
|
253
|
+
jude_project = jude_api_load("model004")
|
254
|
+
human_class = jude_project.find_class_by_name("Human")
|
255
|
+
soul_attr = human_class.find_attribute_by_name("soul")
|
256
|
+
body_attr = human_class.find_attribute_by_name("body")
|
257
|
+
notnull_constraint = soul_attr.constraints[0]
|
258
|
+
|
259
|
+
assert(notnull_constraint.instance_of?(JudeApi::JudeConstraint))
|
260
|
+
assert_equal("notnull", notnull_constraint.specification)
|
261
|
+
assert_equal(1, notnull_constraint.constrained_element.size)
|
262
|
+
assert_same(soul_attr, notnull_constraint.constrained_element[0])
|
263
|
+
|
264
|
+
end
|
265
|
+
|
266
|
+
def test_model005_check_dependency_api
|
267
|
+
|
268
|
+
jude_project = jude_api_load("model005")
|
269
|
+
human_class = jude_project.find_class_by_name("Human")
|
270
|
+
food_class = jude_project.find_class_by_name("Food")
|
271
|
+
eat_dependency = human_class.client_dependencies[0]
|
272
|
+
cook_dependency = human_class.client_dependencies[1]
|
273
|
+
assert_same(eat_dependency, food_class.supplier_dependencies[0])
|
274
|
+
assert_same(cook_dependency, food_class.supplier_dependencies[1])
|
275
|
+
|
276
|
+
assert(eat_dependency.instance_of?(JudeApi::JudeDependency))
|
277
|
+
assert(cook_dependency.instance_of?(JudeApi::JudeDependency))
|
278
|
+
assert_equal("eat", eat_dependency.name)
|
279
|
+
assert_equal("cook", cook_dependency.name)
|
280
|
+
assert_same(human_class, eat_dependency.client)
|
281
|
+
assert_same(human_class, cook_dependency.client)
|
282
|
+
assert_same(food_class, eat_dependency.supplier)
|
283
|
+
assert_same(food_class, cook_dependency.supplier)
|
284
|
+
|
285
|
+
end
|
286
|
+
|
287
|
+
def test_model006_check_genaralization_api
|
288
|
+
|
289
|
+
jude_project = jude_api_load("model006")
|
290
|
+
human_class = jude_project.find_class_by_name("Human")
|
291
|
+
animal_class = jude_project.find_class_by_name("Animal")
|
292
|
+
|
293
|
+
generalization = human_class.generalizations[0]
|
294
|
+
assert(generalization.instance_of?(JudeApi::JudeGeneralization))
|
295
|
+
assert_same(generalization, animal_class.specializations[0])
|
296
|
+
assert_equal("Human_is_a_kind_of_Animal", generalization.name)
|
297
|
+
assert_same(human_class, generalization.sub_type)
|
298
|
+
assert_same(animal_class, generalization.super_type)
|
299
|
+
|
300
|
+
end
|
301
|
+
|
302
|
+
|
303
|
+
def test_model007_check_association_api
|
304
|
+
|
305
|
+
jude_project = jude_api_load("model007")
|
306
|
+
human_class = jude_project.find_class_by_name("Human")
|
307
|
+
car_class = jude_project.find_class_by_name("Car")
|
308
|
+
pet_class = jude_project.find_class_by_name("Pet")
|
309
|
+
foot_class = jude_project.find_class_by_name("Foot")
|
310
|
+
heart_class = jude_project.find_class_by_name("Heart")
|
311
|
+
dream_class = jude_project.find_class_by_name("Dream")
|
312
|
+
love_class = jude_project.find_class_by_name("Love")
|
313
|
+
|
314
|
+
car_attr = human_class.find_attribute_by_name("car")
|
315
|
+
pet_attr = human_class.find_attribute_by_name("pet")
|
316
|
+
foot_attr = human_class.find_attribute_by_name("foot")
|
317
|
+
heart_attr = human_class.find_attribute_by_name("heart")
|
318
|
+
dream_attr = human_class.find_attribute_by_name("dream")
|
319
|
+
love_attr = human_class.find_attribute_by_name("love")
|
320
|
+
|
321
|
+
owner_attr = car_class.attributes[0]
|
322
|
+
master_attr = pet_class.attributes[0]
|
323
|
+
ordered_attr = foot_class.attributes[0]
|
324
|
+
belonged_attr = heart_class.attributes[0]
|
325
|
+
dreamed_attr = dream_class.attributes[0]
|
326
|
+
loved_attr = love_class.attributes[0]
|
327
|
+
|
328
|
+
car_association = car_attr.association
|
329
|
+
pet_association = pet_attr.association
|
330
|
+
foot_association = foot_attr.association
|
331
|
+
heart_association = heart_attr.association
|
332
|
+
dream_association = dream_attr.association
|
333
|
+
love_association = love_attr.association
|
334
|
+
|
335
|
+
assert(car_association.instance_of?(JudeApi::JudeAssociation))
|
336
|
+
assert_equal("Human_has_Car", car_association.name)
|
337
|
+
assert_equal("Human_has_Pet", pet_association.name)
|
338
|
+
assert_equal("Foot_is_a_part_of_Human", foot_association.name)
|
339
|
+
assert_equal("Heart_is_a_part_of_Human", heart_association.name)
|
340
|
+
assert_equal("Human_should_have_Dream", dream_association.name)
|
341
|
+
assert_equal("Human_should_have_Love", love_association.name)
|
342
|
+
|
343
|
+
assert_same(owner_attr, car_association.attributes[0])
|
344
|
+
assert_same(master_attr, pet_association.attributes[0])
|
345
|
+
assert_same(ordered_attr, foot_association.attributes[0])
|
346
|
+
assert_same(belonged_attr, heart_association.attributes[0])
|
347
|
+
assert_same(dreamed_attr, dream_association.attributes[0])
|
348
|
+
assert_same(loved_attr, love_association.attributes[0])
|
349
|
+
|
350
|
+
assert_same(car_attr, car_association.attributes[1])
|
351
|
+
assert_same(pet_attr, pet_association.attributes[1])
|
352
|
+
assert_same(foot_attr, foot_association.attributes[1])
|
353
|
+
assert_same(heart_attr, heart_association.attributes[1])
|
354
|
+
assert_same(dream_attr, dream_association.attributes[1])
|
355
|
+
assert_same(love_attr, love_association.attributes[1])
|
356
|
+
|
357
|
+
end
|
358
|
+
|
359
|
+
def test_model007_check_multiplicities
|
360
|
+
|
361
|
+
jude_project = jude_api_load("model007")
|
362
|
+
human_class = jude_project.find_class_by_name("Human")
|
363
|
+
|
364
|
+
car_attr = human_class.find_attribute_by_name("car")
|
365
|
+
pet_attr = human_class.find_attribute_by_name("pet")
|
366
|
+
foot_attr = human_class.find_attribute_by_name("foot")
|
367
|
+
heart_attr = human_class.find_attribute_by_name("heart")
|
368
|
+
dream_attr = human_class.find_attribute_by_name("dream")
|
369
|
+
love_attr = human_class.find_attribute_by_name("love")
|
370
|
+
|
371
|
+
car_multiplicity = car_attr.multiplicity[0]
|
372
|
+
pet_multiplicity = pet_attr.multiplicity[0]
|
373
|
+
foot_multiplicity = foot_attr.multiplicity[0]
|
374
|
+
heart_multiplicity = heart_attr.multiplicity[0]
|
375
|
+
dream_multiplicity = dream_attr.multiplicity[0]
|
376
|
+
love_multiplicity = love_attr.multiplicity[0]
|
377
|
+
|
378
|
+
assert(car_multiplicity.instance_of?(JudeApi::JudeMultiplicityRange))
|
379
|
+
|
380
|
+
undefined = JudeApi::JudeMultiplicityRange::UNDEFINED
|
381
|
+
unlimited = JudeApi::JudeMultiplicityRange::UNLIMITED
|
382
|
+
assert_equal(-100, undefined)
|
383
|
+
assert_equal(-1, unlimited)
|
384
|
+
|
385
|
+
assert_equal(0, car_multiplicity.lower)
|
386
|
+
assert_equal(unlimited, car_multiplicity.upper)
|
387
|
+
assert_equal(unlimited, pet_multiplicity.lower)
|
388
|
+
assert_equal(unlimited, pet_multiplicity.upper)
|
389
|
+
assert_equal(undefined, foot_multiplicity.lower)
|
390
|
+
assert_equal(undefined, foot_multiplicity.upper)
|
391
|
+
assert_equal(1, heart_multiplicity.lower)
|
392
|
+
assert_equal(1, heart_multiplicity.upper)
|
393
|
+
assert_equal(1, dream_multiplicity.lower)
|
394
|
+
assert_equal(unlimited, dream_multiplicity.upper)
|
395
|
+
assert_equal(0, love_multiplicity.lower)
|
396
|
+
assert_equal(1, love_multiplicity.upper)
|
397
|
+
|
398
|
+
end
|
399
|
+
|
400
|
+
def test_model008_check_association_class_api
|
401
|
+
|
402
|
+
jude_project = jude_api_load("model008")
|
403
|
+
contract_association_class = jude_project.find_association_class_by_name("Contract")
|
404
|
+
employee_class = jude_project.find_class_by_name("Employee")
|
405
|
+
employer_class = jude_project.find_class_by_name("Employer")
|
406
|
+
|
407
|
+
assert(contract_association_class.instance_of?(JudeApi::JudeAssociationClass))
|
408
|
+
assert_same(contract_association_class, employee_class.attributes[0].association)
|
409
|
+
assert_same(contract_association_class, employer_class.attributes[0].association)
|
410
|
+
|
411
|
+
end
|
412
|
+
|
413
|
+
def test_model009_check_model_api
|
414
|
+
|
415
|
+
model009_model = jude_api_load("model009")
|
416
|
+
assert(model009_model.instance_of?(JudeApi::JudeModel))
|
417
|
+
assert_equal("model009", model009_model.name)
|
418
|
+
assert_equal(6, model009_model.owned_elements.size)
|
419
|
+
assert_equal("package1", model009_model.owned_elements[0].name)
|
420
|
+
assert_equal("subsystem1", model009_model.owned_elements[1].name)
|
421
|
+
assert_equal("model1", model009_model.owned_elements[2].name)
|
422
|
+
assert_equal("Class1", model009_model.owned_elements[3].name)
|
423
|
+
assert_equal("actor1", model009_model.owned_elements[4].name)
|
424
|
+
assert_equal("usecase1", model009_model.owned_elements[5].name)
|
425
|
+
assert_equal(1, model009_model.diagrams.size)
|
426
|
+
assert_equal("class-diagram1", model009_model.diagrams[0].name)
|
427
|
+
|
428
|
+
end
|
429
|
+
|
430
|
+
def test_model010_check_subsystem_api
|
431
|
+
|
432
|
+
model010_model = jude_api_load("model010")
|
433
|
+
subsystem1 = model010_model.owned_elements[0]
|
434
|
+
actor1 = subsystem1.owned_elements[0]
|
435
|
+
usecase1 = subsystem1.owned_elements[1]
|
436
|
+
model1 = subsystem1.owned_elements[2]
|
437
|
+
package1 = subsystem1.owned_elements[3]
|
438
|
+
class1 = subsystem1.owned_elements[4]
|
439
|
+
interface1 = subsystem1.owned_elements[5]
|
440
|
+
subsystem2 = subsystem1.owned_elements[6]
|
441
|
+
|
442
|
+
assert(subsystem1.instance_of?(JudeApi::JudeSubsystem))
|
443
|
+
assert(subsystem2.instance_of?(JudeApi::JudeSubsystem))
|
444
|
+
assert_equal("subsystem1", subsystem1.name)
|
445
|
+
assert_equal("subsystem2", subsystem2.name)
|
446
|
+
|
447
|
+
assert_equal("actor1", actor1.name)
|
448
|
+
assert_equal("usecase1", usecase1.name)
|
449
|
+
assert_equal("model1", model1.name)
|
450
|
+
assert_equal("package1", package1.name)
|
451
|
+
assert_equal("Class1", class1.name)
|
452
|
+
assert_equal("interface1", interface1.name)
|
453
|
+
|
454
|
+
assert_equal("operation1", subsystem1.operations[0].name)
|
455
|
+
assert_equal("operation2", subsystem1.operations[1].name)
|
456
|
+
assert_same(subsystem2, subsystem1.generalizations[0].super_type)
|
457
|
+
assert_same(subsystem1, subsystem2.specializations[0].sub_type)
|
458
|
+
assert_same(interface1, subsystem1.client_realizations[0].supplier)
|
459
|
+
|
460
|
+
end
|
461
|
+
|
462
|
+
def test_model011_check_package_api
|
463
|
+
|
464
|
+
model011_model = jude_api_load("model011")
|
465
|
+
package1 = model011_model.owned_elements[0]
|
466
|
+
assert(package1.instance_of?(JudeApi::JudePackage))
|
467
|
+
assert_equal("package1", package1.name)
|
468
|
+
assert_equal("package2", package1.owned_elements[0].name)
|
469
|
+
assert_equal("Class1", package1.owned_elements[1].name)
|
470
|
+
assert_equal("actor1", package1.owned_elements[2].name)
|
471
|
+
assert_equal("usecase1", package1.owned_elements[3].name)
|
472
|
+
assert_equal("subsystem1", package1.owned_elements[4].name)
|
473
|
+
assert_equal(1, package1.diagrams.size)
|
474
|
+
assert_equal("class-diagram1", package1.diagrams[0].name)
|
475
|
+
|
476
|
+
end
|
477
|
+
|
478
|
+
def test_model012_check_usecase_api
|
479
|
+
|
480
|
+
model012_model = jude_api_load("model012")
|
481
|
+
usecase1 = model012_model.owned_elements[0]
|
482
|
+
usecase2 = model012_model.owned_elements[1]
|
483
|
+
usecase3 = model012_model.owned_elements[2]
|
484
|
+
usecase4 = model012_model.owned_elements[3]
|
485
|
+
usecase5 = model012_model.owned_elements[4]
|
486
|
+
|
487
|
+
assert(usecase1.instance_of?(JudeApi::JudeUseCase))
|
488
|
+
assert(usecase2.instance_of?(JudeApi::JudeUseCase))
|
489
|
+
assert(usecase3.instance_of?(JudeApi::JudeUseCase))
|
490
|
+
assert(usecase4.instance_of?(JudeApi::JudeUseCase))
|
491
|
+
assert(usecase5.instance_of?(JudeApi::JudeUseCase))
|
492
|
+
|
493
|
+
assert_equal("usecase1", usecase1.name)
|
494
|
+
assert_equal("usecase2", usecase2.name)
|
495
|
+
assert_equal("usecase3", usecase3.name)
|
496
|
+
assert_equal("usecase4", usecase4.name)
|
497
|
+
assert_equal("usecase5", usecase5.name)
|
498
|
+
assert_equal("extention-point1", usecase1.extension_points[0].name)
|
499
|
+
assert_equal("extention-point2", usecase1.extension_points[1].name)
|
500
|
+
assert_equal("include1", usecase1.includes[0].name)
|
501
|
+
assert_equal("include2", usecase1.includes[1].name)
|
502
|
+
assert_equal("include1", usecase2.addition_invs[0].name)
|
503
|
+
assert_equal("include2", usecase3.addition_invs[0].name)
|
504
|
+
assert_equal("extend1", usecase1.extends[0].name)
|
505
|
+
assert_equal("extend2", usecase1.extends[1].name)
|
506
|
+
assert_equal("extend1", usecase4.extended_case_invs[0].name)
|
507
|
+
assert_equal("extend2", usecase5.extended_case_invs[0].name)
|
508
|
+
|
509
|
+
end
|
510
|
+
|
511
|
+
def test_model012_check_extention_point_api
|
512
|
+
|
513
|
+
model012_model = jude_api_load("model012")
|
514
|
+
usecase1 = model012_model.owned_elements[0]
|
515
|
+
usecase2 = model012_model.owned_elements[1]
|
516
|
+
usecase3 = model012_model.owned_elements[2]
|
517
|
+
usecase4 = model012_model.owned_elements[3]
|
518
|
+
usecase5 = model012_model.owned_elements[4]
|
519
|
+
|
520
|
+
extention_point1 = usecase1.extension_points[0]
|
521
|
+
extention_point2 = usecase1.extension_points[1]
|
522
|
+
assert(extention_point1.instance_of?(JudeApi::JudeExtentionPoint))
|
523
|
+
assert(extention_point2.instance_of?(JudeApi::JudeExtentionPoint))
|
524
|
+
assert_equal("extention-point1", extention_point1.name)
|
525
|
+
assert_equal("extention-point2", extention_point2.name)
|
526
|
+
|
527
|
+
end
|
528
|
+
|
529
|
+
def test_model012_check_extend_api
|
530
|
+
|
531
|
+
model012_model = jude_api_load("model012")
|
532
|
+
usecase1 = model012_model.owned_elements[0]
|
533
|
+
usecase4 = model012_model.owned_elements[3]
|
534
|
+
usecase5 = model012_model.owned_elements[4]
|
535
|
+
|
536
|
+
extend1 = usecase1.extends[0]
|
537
|
+
extend2 = usecase1.extends[1]
|
538
|
+
|
539
|
+
assert(extend1.instance_of?(JudeApi::JudeExtend))
|
540
|
+
assert(extend2.instance_of?(JudeApi::JudeExtend))
|
541
|
+
assert_equal("extend1", extend1.name)
|
542
|
+
assert_equal("extend2", extend2.name)
|
543
|
+
assert_same(usecase1, extend1.extension)
|
544
|
+
assert_same(usecase1, extend2.extension)
|
545
|
+
assert_same(usecase4, extend1.extended_case)
|
546
|
+
assert_same(usecase5, extend2.extended_case)
|
547
|
+
|
548
|
+
end
|
549
|
+
|
550
|
+
def test_model012_check_include_api
|
551
|
+
|
552
|
+
model012_model = jude_api_load("model012")
|
553
|
+
usecase1 = model012_model.owned_elements[0]
|
554
|
+
usecase2 = model012_model.owned_elements[1]
|
555
|
+
usecase3 = model012_model.owned_elements[2]
|
556
|
+
|
557
|
+
include1 = usecase1.includes[0]
|
558
|
+
include2 = usecase1.includes[1]
|
559
|
+
|
560
|
+
assert(include1.instance_of?(JudeApi::JudeInclude))
|
561
|
+
assert(include2.instance_of?(JudeApi::JudeInclude))
|
562
|
+
assert_equal("include1", include1.name)
|
563
|
+
assert_equal("include2", include2.name)
|
564
|
+
assert_same(usecase2, include1.addition)
|
565
|
+
assert_same(usecase3, include2.addition)
|
566
|
+
assert_same(usecase1, include1.including_case)
|
567
|
+
assert_same(usecase1, include2.including_case)
|
568
|
+
|
569
|
+
end
|
570
|
+
|
571
|
+
def test_model013_check_japanese
|
572
|
+
jude_project = jude_api_load("model013")
|
573
|
+
human_class = jude_project.classes[0]
|
574
|
+
assert_equal("日本語テスト", human_class.name)
|
575
|
+
end
|
576
|
+
|
577
|
+
end
|
578
|
+
|
metadata
ADDED
@@ -0,0 +1,73 @@
|
|
1
|
+
--- !ruby/object:Gem::Specification
|
2
|
+
homepage: http://luruju.com
|
3
|
+
extensions: []
|
4
|
+
executables: []
|
5
|
+
version: !ruby/object:Gem::Version
|
6
|
+
version: 0.0.1
|
7
|
+
post_install_message:
|
8
|
+
date: 2007-10-06 15:00:00 +00:00
|
9
|
+
files:
|
10
|
+
- LICENSE
|
11
|
+
- Rakefile
|
12
|
+
- lib/luruju
|
13
|
+
- lib/luruju.rb
|
14
|
+
- lib/luruju/add_useful_method.rb
|
15
|
+
- lib/luruju/dynamic_method.rb
|
16
|
+
- lib/luruju/jude_api.rb
|
17
|
+
- lib/luruju/version.rb
|
18
|
+
- test/abstract_unit.rb
|
19
|
+
- test/jude
|
20
|
+
- test/jude_api_test.rb
|
21
|
+
- test/jude/model001.jude
|
22
|
+
- test/jude/model002.jude
|
23
|
+
- test/jude/model003.jude
|
24
|
+
- test/jude/model004.jude
|
25
|
+
- test/jude/model005.jude
|
26
|
+
- test/jude/model006.jude
|
27
|
+
- test/jude/model007.jude
|
28
|
+
- test/jude/model008.jude
|
29
|
+
- test/jude/model009.jude
|
30
|
+
- test/jude/model010.jude
|
31
|
+
- test/jude/model011.jude
|
32
|
+
- test/jude/model012.jude
|
33
|
+
- test/jude/model013.jude
|
34
|
+
- test/jude/model013.jude.bak
|
35
|
+
rubygems_version: 0.9.4
|
36
|
+
rdoc_options: []
|
37
|
+
signing_key:
|
38
|
+
cert_chain:
|
39
|
+
name: luruju
|
40
|
+
has_rdoc: false
|
41
|
+
platform: ruby
|
42
|
+
summary: A library for coordinating with Ruby And JUDE.
|
43
|
+
default_executable:
|
44
|
+
bindir: bin
|
45
|
+
required_ruby_version: !ruby/object:Gem::Version::Requirement
|
46
|
+
version:
|
47
|
+
requirements:
|
48
|
+
- - '>'
|
49
|
+
- !ruby/object:Gem::Version
|
50
|
+
version: 0.0.0
|
51
|
+
require_paths:
|
52
|
+
- lib
|
53
|
+
specification_version: 1
|
54
|
+
test_files: []
|
55
|
+
dependencies:
|
56
|
+
- !ruby/object:Gem::Dependency
|
57
|
+
name: activesupport
|
58
|
+
version_requirement:
|
59
|
+
version_requirements: !ruby/object:Gem::Version::Requirement
|
60
|
+
version:
|
61
|
+
requirements:
|
62
|
+
- - !str =
|
63
|
+
- !ruby/object:Gem::Version
|
64
|
+
version: 1.4.2
|
65
|
+
description:
|
66
|
+
authors:
|
67
|
+
- Shuhei Nomura
|
68
|
+
email:
|
69
|
+
extra_rdoc_files: []
|
70
|
+
requirements:
|
71
|
+
- JUDE Community
|
72
|
+
rubyforge_project: luruju
|
73
|
+
autorequire: luruju
|