rubeus 0.0.6-java → 0.0.7-java

data/test/rubeus/awt/test_setter.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for setter.rb
+class TestSetter < Test::Unit::TestCase
+  include Rubeus::Swing
+
+  # setup method
+  def setup
+  end
+
+  # test set_preferred_size
+  def test_set_preferred_size
+    JFrame.new do |f|
+      txt = JTextField.new
+      txt.set_preferred_size "100 x 150"
+
+      f.pack
+
+      assert_equal(100, txt.get_preferred_size.width)
+      assert_equal(150, txt.get_preferred_size.height)
+
+      f.dispose
+    end
+  end
+
+  # test preferred_size=
+  def test_preferred_size=
+    JFrame.new do |f|
+      txt = JTextField.new
+      txt.preferred_size = "150 x 100"
+
+      f.pack
+
+      assert_equal(150, txt.preferred_size.width)
+      assert_equal(100, txt.preferred_size.height)
+
+      f.dispose
+    end
+  end
+end

data/test/rubeus/extensions/java/awt/test_dimension.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for Rubeus::Extensions::Java::Awt
+class TestDimension < Test::Unit::TestCase
+	include Rubeus::Awt
+
+	# setup method
+	def setup
+	end
+
+	# create with array size 0
+	def test_create_with_array_size_0
+		d = Dimension.create([])
+
+		assert_equal(0, d.width)
+		assert_equal(0, d.height)
+	end
+
+	# create with array size 1
+	def test_create_with_array_size_1
+		assert_raise(ArgumentError) do
+			d = Dimension.create([200])
+		end
+	end
+
+	# create with array size 2
+	def test_create_with_array_size_2
+		d = Dimension.create([200, 300])
+
+		assert_equal(200, d.width)
+		assert_equal(300, d.height)
+	end
+
+	# create with array size 3
+	def test_create_with_array_size_3
+		assert_raise(ArgumentError) do
+			d = Dimension.create([200, 300, 400])
+		end
+	end
+
+	# create with dimension object
+	def test_create_with_dimension
+		d = Dimension.create([300, 400])
+		d2 = Dimension.create(d)
+
+		assert_equal(d.width, d2.width)
+		assert_equal(d.height, d2.height)
+	end
+
+	# create with multiply expression
+	def test_create_with_multiply expression
+		d = Dimension.create("400 x 500")
+
+		assert_equal(400, d.width)
+		assert_equal(500, d.height)
+	end
+
+	# create with original constructor
+	def test_create_with_original_constructor
+		d = Dimension.create(600, 350)
+
+		assert_equal(600, d.width)
+		assert_equal(350, d.height)
+	end
+end

data/test/rubeus/extensions/java/sql/test_connection.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for connetion.rb
+class TestConnection < Test::Unit::TestCase
+  # setup method
+  def setup
+    @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
+  end
+
+  def test_statement
+    assert_nothing_raised do
+      @con.statement do |stmt|
+      end
+    end
+  end
+
+  def test_query
+    # Drop test table
+    begin
+      @con.statement do |stmt|
+        stmt.execute_update("DROP TABLE TEST")
+      end
+    rescue
+      # table test is already exist
+    end
+
+    @con.statement do |stmt|
+      stmt.execute_update("CREATE TABLE TEST (ID INT, NAME CHAR(10))")
+      stmt.execute_update("INSERT INTO TEST VALUES(1, 'row1')")
+      stmt.execute_update("INSERT INTO TEST VALUES(2, 'row2')")
+    end
+
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      i = 1
+      rs.each_hash do |rsNext|
+        assert_equal(i, rsNext["ID"])
+        assert_equal("row#{i}      ", rsNext["NAME"])
+
+        i += 1
+      end
+    end
+  end
+
+  def teardown
+    @con.close
+  end
+end
+

data/test/rubeus/extensions/java/sql/test_driver_manager.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for driver_manager.rb
+class TestDriverManager < Test::Unit::TestCase
+  # setup method
+  def setup
+  end
+
+  def test_normal
+    assert_nothing_raised do
+      @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
+    end
+
+    if @con
+      assert_equal(false, @con.closed?)
+      @con.close
+    end
+  end
+
+  def test_without_auto_setup_manager
+    assert_nothing_raised do
+      org.apache.derby.jdbc.EmbeddedDriver
+      @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "", :auto_setup_manager => false)
+      @con.close
+    end
+  end
+
+  def test_with_block
+    con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true") do |con|
+      assert_equal(false, con.closed?)
+    end
+    assert_nil(con)
+  end
+end
+

data/test/rubeus/extensions/java/sql/test_result_set.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for result_set.rb
+class TestResultSet < Test::Unit::TestCase
+  # setup method
+  def setup
+    @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
+
+    # Drop test table
+    begin
+      @con.statement do |stmt|
+        stmt.execute_update("DROP TABLE TEST")
+      end
+    rescue
+      # table test is already exist
+    end
+
+    @con.statement do |stmt|
+      stmt.execute_update("CREATE TABLE TEST (ID INT, NAME CHAR(10))")
+      stmt.execute_update("INSERT INTO TEST VALUES(1, 'row1')")
+      stmt.execute_update("INSERT INTO TEST VALUES(2, 'row2')")
+    end
+  end
+
+  def test_each
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      i = 1
+      rs.each do |rsNext|
+        assert_equal(i, rsNext.get_int("ID"))
+        assert_equal("row#{i}      ", rsNext.get_string("NAME"))
+
+        i += 1
+      end
+    end
+  end
+
+  def test_each_array
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      i = 1
+      rs.each_array do |rsNext|
+        assert_equal(i, rsNext[0])
+        assert_equal("row#{i}      ", rsNext[1])
+
+        i += 1
+      end
+    end
+  end
+
+  def test_each_hash
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      i = 1
+      rs.each_hash do |rsNext|
+        assert_equal(i, rsNext["ID"])
+        assert_equal("row#{i}      ", rsNext["NAME"])
+
+        i += 1
+      end
+    end
+  end
+
+  def teardown
+    @con.close
+  end
+end
+

data/test/rubeus/extensions/java/sql/test_result_set_meta_data.rb

@@ -0,0 +1,121 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for result_set_meta_data.rb
+class TestResultSetMetaData < Test::Unit::TestCase
+  # setup method
+  def setup
+    @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
+
+    # Drop test table
+    begin
+      @con.statement do |stmt|
+        stmt.execute_update("DROP TABLE TEST")
+      end
+    rescue
+      # table test is already exist
+    end
+
+    @con.statement do |stmt|
+      stmt.execute_update("CREATE TABLE TEST (ID INT, NAME CHAR(10))")
+    end
+  end
+
+  def test_each_without_block
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      assert_nil(rs.meta_data.each)
+    end
+  end
+
+  def test_each_with_block
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      i = 1
+      rs.meta_data.each do |rsMeta|
+        assert_equal(i, rsMeta)
+        i += 1
+      end
+    end
+  end
+
+  def test_columns
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      i = 1
+      rs.meta_data.columns.each do |column|
+        if i == 1
+          assert_equal("java.lang.Integer", column.column_class_name)
+          assert_equal("java.lang.Integer", column.class_name)
+          assert_equal(11, column.column_display_size)
+          assert_equal(11, column.display_size)
+          assert_equal("ID", column.column_label)
+          assert_equal("ID", column.label)
+          assert_equal("ID", column.column_name)
+          assert_equal("ID", column.name)
+          assert_equal("INTEGER", column.column_type_name)
+          assert_equal("INTEGER", column.type_name)
+          assert_equal(false, column.case_sensitive)
+          assert_equal(false, column.case_sensitive?)
+          assert_equal(true, column.signed)
+          assert_equal(true, column.signed?)
+        elsif i == 2
+          assert_equal("java.lang.String", column.column_class_name)
+          assert_equal("java.lang.String", column.class_name)
+          assert_equal(10, column.column_display_size)
+          assert_equal(10, column.display_size)
+          assert_equal("NAME", column.column_label)
+          assert_equal("NAME", column.label)
+          assert_equal("NAME", column.column_name)
+          assert_equal("NAME", column.name)
+          assert_equal("CHAR", column.column_type_name)
+          assert_equal("CHAR", column.type_name)
+          assert_equal(true, column.case_sensitive)
+          assert_equal(true, column.case_sensitive?)
+          assert_equal(false, column.signed)
+          assert_equal(false, column.signed?)
+        end
+
+        # common test
+        assert_equal(i, column.column_index)
+        assert_equal(i, column.index)
+        assert_equal(false, column.auto_increment)
+        assert_equal(false, column.auto_increment?)
+        assert_equal(false, column.currency)
+        assert_equal(false, column.currency?)
+        assert_equal(false, column.definitely_writable)
+        assert_equal(false, column.definitely_writable?)
+
+        # java.sql.ResultSetMetaData.const_get(:columnNullable) has error
+        assert_equal(1, column.is_nullable)
+
+        assert_equal(false, column.read_only)
+        assert_equal(false, column.read_only?)
+        assert_equal(true, column.searchable)
+        assert_equal(true, column.searchable?)
+        assert_equal(false, column.writable)
+        assert_equal(false, column.writable?)
+
+        i += 1
+      end
+    end
+  end
+
+  def test_column_names
+    expected_column_names = {1 => "ID", 2 => "NAME"}
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      assert_equal(expected_column_names, rs.meta_data.column_names)
+    end
+  end
+
+  def test_column_index
+    @con.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+      rs.meta_data.each do |rsMeta|
+        assert_equal(rsMeta, rs.meta_data.column_index(rsMeta))
+      end
+    end
+  end
+
+  def teardown
+    @con.close
+  end
+end
+

data/test/rubeus/extensions/java/sql/test_statement.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+
+# Test for statement.rb
+class TestStatement < Test::Unit::TestCase
+  # setup method
+  def setup
+    @con = Rubeus::Jdbc::DriverManager.connect("jdbc:derby:test_db;create = true", "", "")
+  end
+
+  def test_query
+    # Drop test table
+    begin
+      @con.statement do |stmt|
+        stmt.execute_update("DROP TABLE TEST")
+      end
+    rescue
+      # table test is already exist
+    end
+
+    @con.statement do |stmt|
+      stmt.execute_update("CREATE TABLE TEST (ID INT, NAME CHAR(10))")
+      stmt.execute_update("INSERT INTO TEST VALUES(1, 'row1')")
+      stmt.execute_update("INSERT INTO TEST VALUES(2, 'row2')")
+
+      stmt.query("SELECT * FROM TEST ORDER BY ID") do |rs|
+        i = 1
+        rs.each_hash do |rsNext|
+          assert_equal(i, rsNext["ID"])
+          assert_equal("row#{i}      ", rsNext["NAME"])
+
+          i += 1
+        end
+      end
+    end
+  end
+
+  def teardown
+    @con.close
+  end
+end
+

data/test/rubeus/extensions/javax/swing/table/test_default_table_model.rb

@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+require 'test/unit'
+require 'rubygems'
+require 'rubeus'
+require 'rexml/document'
+
+# Rubeus.verbose = true
+
+# Test for Rubeus::Extensions::Javax::Swing::Table
+class TestDefaultTableModel < Test::Unit::TestCase
+  include Rubeus::Swing
+
+  # setup method
+  def setup
+    # Load XML File
+    open(File.join(File.dirname(__FILE__), 'test_default_table_model', 'nhk_words.xml')) do |f|
+      @xml = REXML::Document.new(f)
+    end
+  end
+
+  # normal pattern
+  def test_load_from_xml_normal
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word',
+      :column_paths => ['id', 'expression'])
+
+    assert_for_normal(nhk_word_table)
+  end
+
+  # utility for assert method for normal
+  def assert_for_normal(nhk_word_table)
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+
+    # assert first row
+    assert_equal("1", nhk_word_table.model.get_value_at(0, 0))
+    assert_equal("ないわ～", nhk_word_table.model.get_value_at(0, 1))
+
+    # assert second row
+    assert_equal("2", nhk_word_table.model.get_value_at(1, 0))
+    assert_equal("格好いい", nhk_word_table.model.get_value_at(1, 1))
+  end
+  private :assert_for_normal
+
+  # row_path is nil
+  def test_load_from_xml_nil_row_path
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    assert_raise(ArgumentError) do
+      nhk_word_table.model.load_from_xml(@xml,
+        :column_paths => ['id', 'expression'])
+    end
+  end
+
+  # invalid row_path
+  def test_load_from_xml_invalid_row_path
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-words',
+      :column_paths => ['id', 'expression'])
+
+    # assert row count
+    assert_equal(0, nhk_word_table.model.row_count)
+  end
+
+  # nil column_paths
+  def test_load_from_xml_nil_column_paths
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word')
+
+    # assert for normal
+    assert_for_normal(nhk_word_table)
+  end
+
+  # nil column_paths with refresh_columns
+  def test_load_from_xml_nil_column_paths_with_refresh_columns
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word',
+      :refresh_columns => true)
+
+    # assert for normal
+    assert_for_normal(nhk_word_table)
+  end
+
+  # invalid column_paths
+  def test_load_from_xml_invalid_column_paths
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    assert_raise(ArgumentError) do
+      nhk_word_table.model.load_from_xml(@xml,
+        :row_path => '*/nhk-word',
+        :column_paths => ['ida', 'expression'])
+    end
+  end
+
+  # less number of columns
+  def test_load_from_xml_less_number_of_columns
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word',
+      :column_paths => ['id'])
+
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+
+    # assert first row
+    assert_equal("1", nhk_word_table.model.get_value_at(0, 0))
+    assert_nil(nhk_word_table.model.get_value_at(0, 1))
+
+    # assert second row
+    assert_equal("2", nhk_word_table.model.get_value_at(1, 0))
+    assert_nil(nhk_word_table.model.get_value_at(1, 1))
+  end
+
+  # less number of columns with refresh_columns
+  def test_load_from_xml_less_number_of_columns_with_refresh_columns
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word',
+      :column_paths => ['id'], 
+      :refresh_columns => true)
+
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+    assert_equal(1, nhk_word_table.model.column_count)
+
+    # assert first row
+    assert_equal("1", nhk_word_table.model.get_value_at(0, 0))
+
+    # assert second row
+    assert_equal("2", nhk_word_table.model.get_value_at(1, 0))
+  end
+
+  # large number of columns
+  def test_load_from_xml_large_number_of_columns
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word',
+      :column_paths => ['id', 'expression', 'created-at'])
+
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+  end
+
+  # large number of columns with refresh_columns
+  def test_load_from_xml_large_number_of_columns_with_refresh_columns
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # load_from_xml
+    nhk_word_table.model.load_from_xml(@xml,
+      :row_path => '*/nhk-word',
+      :column_paths => ['id', 'expression', 'created-at'], 
+      :refresh_columns => true)
+
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+    assert_equal(3, nhk_word_table.model.column_count)
+
+    # assert for normal
+    assert_for_normal(nhk_word_table)
+
+    # assert first row
+    assert_equal("2008-08-13T20:35:00Z", nhk_word_table.model.get_value_at(0, 2))
+
+    # assert second row
+    assert_equal("2008-08-13T20:36:00Z", nhk_word_table.model.get_value_at(1, 2))
+  end
+
+  # insert_row
+  def test_insert_row
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # Insert Rows
+    nhk_word_table.model.insert_row(0, [1, "いんさーと"])
+    nhk_word_table.model.insert_row(0, [2, "インサートその2"])
+
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+
+    # assert first row
+    assert_equal(2, nhk_word_table.model.get_value_at(0, 0))
+    assert_equal("インサートその2", nhk_word_table.model.get_value_at(0, 1))
+
+    # assert second row
+    assert_equal(1, nhk_word_table.model.get_value_at(1, 0))
+    assert_equal("いんさーと", nhk_word_table.model.get_value_at(1, 1))
+  end
+
+  # add_row
+  def test_add_row
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ['ID', 'NHK語']
+
+    # Insert Rows
+    nhk_word_table.model.add_row([1, "いんさーと"])
+    nhk_word_table.model.add_row([2, "インサートその2"])
+
+    # assert row count
+    assert_equal(2, nhk_word_table.model.row_count)
+
+    # assert first row
+    assert_equal(1, nhk_word_table.model.get_value_at(0, 0))
+    assert_equal("いんさーと", nhk_word_table.model.get_value_at(0, 1))
+
+    # assert second row
+    assert_equal(2, nhk_word_table.model.get_value_at(1, 0))
+    assert_equal("インサートその2", nhk_word_table.model.get_value_at(1, 1))
+  end
+
+  # new with 2d-Array
+  def test_new_with_2dArray
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = [[1, "1行目"], [2, "2行目"], [3, "3行目"]]
+
+    # assert row count
+    assert_equal(3, nhk_word_table.model.row_count)
+
+    # assert column count
+    assert_equal(2, nhk_word_table.model.column_count)
+
+    # assert rows
+    for i in 1..nhk_word_table.model.row_count
+      assert_equal(i, nhk_word_table.model.get_value_at((i-1), 0))
+      assert_equal("#{i}行目", nhk_word_table.model.get_value_at((i-1), 1))
+    end
+
+    # assert columns
+    for i in 1..nhk_word_table.model.column_count
+      assert_equal(i.to_s, nhk_word_table.model.getColumnName(i-1))
+    end
+  end
+
+  # new with Array
+  def test_new_with_array
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = ["ID", "NHK語"]
+
+    # assert row count
+    assert_equal(0, nhk_word_table.model.row_count)
+
+    # assert column count
+    assert_equal(2, nhk_word_table.model.column_count)
+
+    # assert columns
+    assert_equal("ID", nhk_word_table.model.get_column_name(0))
+    assert_equal("NHK語", nhk_word_table.model.get_column_name(1))
+  end
+
+  # new with Hash
+  def test_new_with_hash_data_column_names
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = {:data => [["1", "ないわ～"], ["2", "格好いい"]], :column_names => ["ID", "NHK語"]}
+
+    assert_for_normal(nhk_word_table)
+  end
+
+  # new with Hash
+  def test_new_with_hash_rows_columns
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = {:rows => [["1", "ないわ～"], ["2", "格好いい"]], :columns => ["ID", "NHK語"]}
+
+    assert_for_normal(nhk_word_table)
+  end
+
+  # new with Hash nil rows
+  def test_new_with_hash_nil_rows
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+
+    assert_raise(ArgumentError) do
+      nhk_word_table.model = {:columns => ["ID", "NHK語"]}
+    end
+  end
+
+  # new with Hash nil cols
+  def test_new_with_hash_nil_cols
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+
+    assert_raise(ArgumentError) do
+      nhk_word_table.model = {:rows => [["1", "ないわ～"], ["2", "格好いい"]]}
+    end
+  end
+
+  # new with XML
+  def test_new_with_xml
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = DefaultTableModel.new(@xml, {:row_path => '*/nhk-word', :column_paths => ['id', 'expression']})
+
+    assert_for_normal(nhk_word_table)
+  end
+
+  # new with original constructor
+  def test_new_with_original_constructor
+    # Initialize JTable and model
+    nhk_word_table = JTable.new
+    nhk_word_table.model = DefaultTableModel.new(4, 3)
+
+    # assert row count
+    assert_equal(4, nhk_word_table.model.row_count)
+
+    # assert column count
+    assert_equal(3, nhk_word_table.model.column_count)
+
+    # assert cells
+    for i in 1..nhk_word_table.model.row_count
+      for j in 1..nhk_word_table.model.column_count
+        assert_nil(nhk_word_table.model.get_value_at((i-1), (j-1)))
+      end
+    end
+  end
+end