caxlsx 2.0.2

data/test/workbook/worksheet/tc_cfvo.rb

@@ -0,0 +1,31 @@
+require 'tc_helper.rb'
+
+class TestCfvo < Test::Unit::TestCase
+  def setup
+    @cfvo = Axlsx::Cfvo.new(:val => "0", :type => :min)
+  end
+
+  def test_val
+    assert_nothing_raised { @cfvo.val = "abc" }
+    assert_equal(@cfvo.val, "abc")
+  end
+
+  def test_type
+    assert_raise(ArgumentError) { @cfvo.type = :invalid_type }
+    assert_nothing_raised { @cfvo.type = :max }
+    assert_equal(@cfvo.type, :max)
+  end
+
+  def test_gte
+    assert_raise(ArgumentError) { @cfvo.gte = :bob }
+    assert_equal(@cfvo.gte, true)
+    assert_nothing_raised { @cfvo.gte = false }
+    assert_equal(@cfvo.gte, false)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML.parse(@cfvo.to_xml_string)
+    assert doc.xpath(".//cfvo[@type='min'][@val=0][@gte=true]")
+  end
+
+end

data/test/workbook/worksheet/tc_col.rb

@@ -0,0 +1,78 @@
+require 'tc_helper.rb'
+
+class TestCol < Test::Unit::TestCase
+
+  def setup
+    @col = Axlsx::Col.new 1, 1
+  end
+
+  def test_initialize
+    options = { :width => 12, :collapsed => true, :hidden => true, :outline_level => 1, :phonetic => true, :style => 1} 
+
+    col = Axlsx::Col.new 0, 0, options
+    options.each{ |key, value| assert_equal(col.send(key.to_sym), value) }
+  end
+
+  def test_min_max_required
+    assert_raise(ArgumentError, 'min and max must be specified when creating a new column') { Axlsx::Col.new }
+    assert_raise(ArgumentError, 'min and max must be specified when creating a new column') { Axlsx::Col.new nil, nil }
+    assert_nothing_raised { Axlsx::Col.new 1, 1 }
+  end
+
+  def test_bestFit
+    assert_equal(@col.bestFit, nil)
+    assert_raise(NoMethodError, 'bestFit is read only') { @col.bestFit = 'bob' }
+    @col.width = 1.999
+    assert_equal(@col.bestFit, true, 'bestFit should be true when width has been set')
+  end
+
+  def test_collapsed
+    assert_equal(@col.collapsed, nil)
+    assert_raise(ArgumentError, 'collapsed must be boolean(ish)') { @col.collapsed = 'bob' }
+    assert_nothing_raised('collapsed must be boolean(ish)') { @col.collapsed = true }
+  end
+
+  def test_customWidth
+    assert_equal(@col.customWidth, nil)
+    @col.width = 3
+    assert_raise(NoMethodError, 'customWidth is read only') { @col.customWidth = 3 }
+    assert_equal(@col.customWidth, true, 'customWidth is true when width is set')
+  end
+
+  def test_hidden
+    assert_equal(@col.hidden, nil)
+    assert_raise(ArgumentError, 'hidden must be boolean(ish)') { @col.hidden = 'bob' }
+    assert_nothing_raised(ArgumentError, 'hidden must be boolean(ish)') { @col.hidden = true }
+  end
+
+  def test_outlineLevel
+    assert_equal(@col.outlineLevel, nil)
+    assert_raise(ArgumentError, 'outline level cannot be negative') { @col.outlineLevel = -1 }
+    assert_raise(ArgumentError, 'outline level cannot be greater than 7') { @col.outlineLevel = 8 }
+    assert_nothing_raised('can set outlineLevel') { @col.outlineLevel = 1 }
+  end
+
+  def test_phonetic
+    assert_equal(@col.phonetic, nil)
+    assert_raise(ArgumentError, 'phonetic must be boolean(ish)') { @col.phonetic = 'bob' }
+    assert_nothing_raised(ArgumentError, 'phonetic must be boolean(ish)') { @col.phonetic = true }
+  end
+
+  def test_to_xml_string
+    @col.width = 100
+    doc = Nokogiri::XML(@col.to_xml_string)
+    assert_equal(1, doc.xpath("//col [@bestFit='#{@col.best_fit}']").size)
+    assert_equal(1, doc.xpath("//col [@max=#{@col.max}]").size)
+    assert_equal(1, doc.xpath("//col [@min=#{@col.min}]").size)
+    assert_equal(1, doc.xpath("//col [@width=#{@col.width}]").size)
+    assert_equal(1, doc.xpath("//col [@customWidth='#{@col.custom_width}']").size)
+  end
+
+  def test_style
+    assert_equal(@col.style, nil)
+    @col.style = 1
+    assert_equal(@col.style, 1)
+    #TODO check that the style specified is actually in the styles xfs collection
+  end
+
+end

data/test/workbook/worksheet/tc_color_scale.rb

@@ -0,0 +1,58 @@
+require 'tc_helper.rb'
+
+class TestColorScale < Test::Unit::TestCase
+  def setup
+    @color_scale = Axlsx::ColorScale.new
+  end
+
+  def test_three_tone
+    color_scale = Axlsx::ColorScale.three_tone
+    assert_equal 3, color_scale.value_objects.size
+    assert_equal 3, color_scale.colors.size
+  end
+
+  def test_two_tone
+    color_scale = Axlsx::ColorScale.two_tone
+    assert_equal 2, color_scale.value_objects.size
+    assert_equal 2, color_scale.colors.size
+  end
+  def test_default_cfvo
+    first = Axlsx::ColorScale.default_cfvos.first
+    second = Axlsx::ColorScale.default_cfvos.last
+    assert_equal 'FFFF7128', first[:color]
+    assert_equal :min,first[:type]
+    assert_equal 0, first[:val]
+
+    assert_equal 'FFFFEF9C', second[:color]
+    assert_equal :max, second[:type]
+    assert_equal 0, second[:val]
+  end
+
+  def test_partial_default_cfvo_override
+    first_def = {:type => :percent, :val => "10.0", :color => 'FF00FF00'}
+    color_scale = Axlsx::ColorScale.new(first_def)
+    assert_equal color_scale.value_objects.first.val, first_def[:val]
+    assert_equal color_scale.value_objects.first.type, first_def[:type]
+    assert_equal color_scale.colors.first.rgb, first_def[:color]
+  end
+
+  def test_add
+    @color_scale.add :type => :max, :val => 5, :color => "FFDEDEDE"
+    assert_equal(@color_scale.value_objects.size,3)
+    assert_equal(@color_scale.colors.size,3)
+  end
+
+  def test_delete_at
+    @color_scale.add :type => :max, :val => 5, :color => "FFDEDEDE"
+    assert_nothing_raised {@color_scale.delete_at 2}
+    assert_equal(@color_scale.value_objects.size,2)
+    assert_equal(@color_scale.colors.size,2)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML.parse(@color_scale.to_xml_string)
+    assert_equal(doc.xpath(".//colorScale//cfvo").size, 2)
+    assert_equal(doc.xpath(".//colorScale//color").size, 2)
+  end
+
+end

data/test/workbook/worksheet/tc_comment.rb

@@ -0,0 +1,72 @@
+require 'tc_helper.rb'
+
+class TestComment < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    wb = p.workbook
+    @ws = wb.add_worksheet
+    @c1 = @ws.add_comment :ref => 'A1', :text => 'text with special char <', :author => 'author with special char <', :visible => false
+    @c2 = @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
+  end
+
+  def test_initailize
+    assert_raise(ArgumentError) { Axlsx::Comment.new }
+  end
+
+  def test_author
+    assert(@c1.author == 'author with special char <')
+    assert(@c2.author == 'PO')
+  end
+
+  def test_text
+    assert(@c1.text == 'text with special char <')
+    assert(@c2.text == 'rust bucket')
+  end
+
+  def test_author_index
+    assert_equal(@c1.author_index, 1)
+    assert_equal(@c2.author_index, 0)
+  end
+
+  def test_visible
+    assert_equal(false, @c1.visible)
+    assert_equal(true, @c2.visible)
+  end
+  def test_ref
+    assert(@c1.ref == 'A1')
+    assert(@c2.ref == 'C3')
+  end
+
+  def test_vml_shape
+    pos = Axlsx::name_to_indices(@c1.ref)
+    assert(@c1.vml_shape.is_a?(Axlsx::VmlShape))
+    assert(@c1.vml_shape.column == pos[0])
+    assert(@c1.vml_shape.row == pos[1])
+    assert(@c1.vml_shape.row == pos[1])
+    assert_equal(pos[0], @c1.vml_shape.left_column)
+    assert(@c1.vml_shape.top_row == pos[1])
+    assert_equal(pos[0] + 2 , @c1.vml_shape.right_column)
+    assert(@c1.vml_shape.bottom_row == pos[1]+4)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@c1.to_xml_string)
+    assert_equal(doc.xpath("//comment[@ref='#{@c1.ref}']").size, 1)
+    assert_equal(doc.xpath("//comment[@authorId='#{@c1.author_index.to_s}']").size, 1)
+    assert_equal(doc.xpath("//t[text()='#{@c1.author}:\n']").size, 1)
+    assert_equal(doc.xpath("//t[text()='#{@c1.text}']").size, 1)
+  end
+
+  def test_comment_text_contain_author_and_text
+    comment = @ws.add_comment :ref => 'C4', :text => 'some text', :author => 'Bob'
+    doc = Nokogiri::XML(comment.to_xml_string)
+    assert_equal("Bob:\nsome text", doc.xpath("//comment/text").text)
+  end
+
+  def test_comment_text_does_not_contain_stray_colon_if_author_blank
+    comment = @ws.add_comment :ref => 'C5', :text => 'some text', :author => ''
+    doc = Nokogiri::XML(comment.to_xml_string)
+    assert_equal("some text", doc.xpath("//comment/text").text)
+  end
+end
+

data/test/workbook/worksheet/tc_comments.rb

@@ -0,0 +1,57 @@
+require 'tc_helper.rb'
+
+class TestComments < Test::Unit::TestCase
+  def setup
+    p = Axlsx::Package.new
+    wb = p.workbook
+    @ws = wb.add_worksheet
+    @c1 = @ws.add_comment :ref => 'A1', :text => 'penut machine', :author => 'crank'
+    @c2 = @ws.add_comment :ref => 'C3', :text => 'rust bucket', :author => 'PO'
+  end
+
+  def test_initialize
+    assert_raise(ArgumentError) { Axlsx::Comments.new }
+    assert(@ws.comments.vml_drawing.is_a?(Axlsx::VmlDrawing))
+  end
+
+  def test_add_comment
+    assert_equal(@ws.comments.size, 2)
+    assert_raise(ArgumentError) { @ws.comments.add_comment() }
+    assert_raise(ArgumentError) { @ws.comments.add_comment(:text => 'Yes We Can', :ref => 'A1') }
+    assert_raise(ArgumentError) { @ws.comments.add_comment(:author => 'bob', :ref => 'A1') }
+    assert_raise(ArgumentError) { @ws.comments.add_comment(:author => 'bob', :text => 'Yes We Can')}
+    assert_nothing_raised { @ws.comments.add_comment(:author => 'bob', :text => 'Yes We Can', :ref => 'A1') }
+    assert_equal(@ws.comments.size, 3)
+  end
+  def test_authors
+    assert_equal(@ws.comments.authors.size, @ws.comments.size)
+    @ws.add_comment(:text => 'Yes We Can!', :author => 'bob', :ref => 'F1')
+    assert_equal(@ws.comments.authors.size, 3)
+    @ws.add_comment(:text => 'Yes We Can!', :author => 'bob', :ref => 'F1')
+    assert_equal(@ws.comments.authors.size, 3, 'only unique authors are returned') 
+  end
+  def test_pn
+    assert_equal(@ws.comments.pn, Axlsx::COMMENT_PN % (@ws.index+1).to_s)
+  end
+
+  def test_index
+    assert_equal(@ws.index, @ws.comments.index)
+  end
+
+  def test_to_xml_string
+    doc = Nokogiri::XML(@ws.comments.to_xml_string)
+    schema = Nokogiri::XML::Schema(File.open(Axlsx::SML_XSD))
+    errors = []
+    schema.validate(doc).each do |error|
+      errors << error
+    end
+    assert_equal(0, errors.length)
+
+    # TODO figure out why these xpath expressions dont work!
+    # assert(doc.xpath("//comments"))
+    # assert_equal(doc.xpath("//xmlns:author").size, @ws.comments.authors.size)
+    # assert_equal(doc.xpath("//comment").size, @ws.comments.size)
+  end
+end
+
+

data/test/workbook/worksheet/tc_conditional_formatting.rb

@@ -0,0 +1,224 @@
+require 'tc_helper.rb'
+
+class TestConditionalFormatting < Test::Unit::TestCase
+
+  def setup
+    p = Axlsx::Package.new
+    @ws = p.workbook.add_worksheet :name=>"hmmm"
+    @cfs = @ws.add_conditional_formatting( "A1:A1", [{ :type => :cellIs, :dxfId => 0, :priority => 1, :operator => :greaterThan, :formula => "0.5" }])
+    @cf = @cfs.first
+    @cfr = @cf.rules.first
+  end
+
+  def test_initialize_with_options
+    optioned = Axlsx::ConditionalFormatting.new( :sqref => "AA1:AB100", :rules => [1, 2] )
+    assert_equal("AA1:AB100", optioned.sqref)
+    assert_equal([1, 2], optioned.rules)
+  end
+  def test_add_as_rule
+
+    color_scale = Axlsx::ColorScale.new do |cs|
+      cs.colors.first.rgb = "FFDFDFDF"
+      cs.colors.last.rgb = "FF00FF00"
+      cs.value_objects.first.type = :percentile
+      cs.value_objects.first.val = 5
+    end
+
+    data_bar = Axlsx::DataBar.new :color => "FFFF0000"
+    icon_set = Axlsx::IconSet.new :iconSet => "5Rating"
+    cfr = Axlsx::ConditionalFormattingRule.new( { :type => :containsText, :text => "TRUE",
+                                                      :dxfId => 0, :priority => 1,
+                                                      :formula => 'NOT(ISERROR(SEARCH("FALSE",AB1)))',
+                                                      :color_scale => color_scale,
+                                                      :data_bar => data_bar,
+                                                      :icon_set => icon_set})
+
+    assert(cfr.data_bar.is_a?(Axlsx::DataBar))
+    assert(cfr.icon_set.is_a?(Axlsx::IconSet))
+    assert(cfr.color_scale.is_a?(Axlsx::ColorScale))
+    cfs = @ws.add_conditional_formatting( "B2:B2", [cfr])
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(1, doc.xpath(".//conditionalFormatting[@sqref='B2:B2']//cfRule[@type='containsText'][@dxfId=0][@priority=1]").size)
+    assert doc.xpath(".//conditionalFormatting//cfRule[@type='containsText'][@dxfId=0][@priority=1]//formula='NOT(ISERROR(SEARCH(\"FALSE\",AB1)))'")
+
+    cfs.last.rules.last.type = :colorScale
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//colorScale//cfvo").size, 2)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//colorScale//color").size, 2)
+
+    cfs.last.rules.last.type = :dataBar
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar").size, 1)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar//cfvo").size, 2)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar//color[@rgb='FFFF0000']").size, 1)
+
+    cfs.last.rules.last.type = :iconSet
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//iconSet//cfvo").size, 3)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//iconSet[@iconSet='5Rating']").size, 1)
+
+  end
+
+
+  def test_add_as_hash
+
+    color_scale = Axlsx::ColorScale.new do |cs|
+      cs.colors.first.rgb = "FFDFDFDF"
+      cs.colors.last.rgb = "FF00FF00"
+      cs.value_objects.first.type = :percentile
+      cs.value_objects.first.val = 5
+    end
+
+    data_bar = Axlsx::DataBar.new :color => "FFFF0000"
+    icon_set = Axlsx::IconSet.new :iconSet => "5Rating"
+
+    cfs = @ws.add_conditional_formatting( "B2:B2", [{ :type => :containsText, :text => "TRUE",
+                                                      :dxfId => 0, :priority => 1,
+                                                      :formula => 'NOT(ISERROR(SEARCH("FALSE",AB1)))',
+                                                      :color_scale => color_scale,
+                                                      :data_bar => data_bar,
+                                                      :icon_set => icon_set}])
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(1, doc.xpath(".//conditionalFormatting[@sqref='B2:B2']//cfRule[@type='containsText'][@dxfId=0][@priority=1]").size)
+    assert doc.xpath(".//conditionalFormatting//cfRule[@type='containsText'][@dxfId=0][@priority=1]//formula='NOT(ISERROR(SEARCH(\"FALSE\",AB1)))'")
+
+    cfs.last.rules.last.type = :colorScale
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//colorScale//cfvo").size, 2)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//colorScale//color").size, 2)
+
+    cfs.last.rules.last.type = :dataBar
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar").size, 1)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar//cfvo").size, 2)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//dataBar//color[@rgb='FFFF0000']").size, 1)
+
+    cfs.last.rules.last.type = :iconSet
+    doc = Nokogiri::XML.parse(cfs.last.to_xml_string)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//iconSet//cfvo").size, 3)
+    assert_equal(doc.xpath(".//conditionalFormatting//cfRule//iconSet[@iconSet='5Rating']").size, 1)
+
+  end
+
+  def test_single_rule
+    doc = Nokogiri::XML.parse(@cf.to_xml_string)
+    assert_equal(1, doc.xpath(".//conditionalFormatting//cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']").size)
+    assert doc.xpath(".//conditionalFormatting//cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']//formula='0.5'")
+  end
+
+  def test_many_options
+    cf = Axlsx::ConditionalFormatting.new( :sqref => "B3:B4" )
+    cf.add_rule({:type => :cellIs, :aboveAverage => false, :bottom => false, :dxfId => 0,
+                 :equalAverage => false, :priority => 2, :operator => :lessThan, :text => "",
+                 :percent => false, :rank => 0, :stdDev => 1, :stopIfTrue => true, :timePeriod => :today,
+                 :formula => "0.0"})
+    doc = Nokogiri::XML.parse(cf.to_xml_string)
+    assert_equal(1, doc.xpath(".//conditionalFormatting//cfRule[@type='cellIs'][@aboveAverage='false'][@bottom='false'][@dxfId=0][@equalAverage='false'][@priority=2][@operator='lessThan'][@text=''][@percent='false'][@rank=0][@stdDev=1][@stopIfTrue='true'][@timePeriod='today']").size)
+    assert doc.xpath(".//conditionalFormatting//cfRule[@type='cellIs'][@aboveAverage='false'][@bottom='false'][@dxfId=0][@equalAverage='false'][@priority=2][@operator='lessThan'][@text=''][@percent='false'][@rank=0][@stdDev=1][@stopIfTrue='true'][@timePeriod='today']//formula=0.0")
+  end
+
+  def test_to_xml
+    doc = Nokogiri::XML.parse(@ws.to_xml_string)
+    assert_equal(1, doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']").size)
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']//xmlns:formula='0.5'")
+  end
+
+  def test_multiple_formats
+    @ws.add_conditional_formatting "B3:B3", { :type => :cellIs, :dxfId => 0, :priority => 1, :operator => :greaterThan, :formula => "1" }
+    doc = Nokogiri::XML.parse(@ws.to_xml_string)
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']//xmlns:formula='1'")
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='greaterThan']//xmlns:formula='0.5'")
+  end
+
+  def test_multiple_formulas
+    @ws.add_conditional_formatting "B3:B3", { :type => :cellIs, :dxfId => 0, :priority => 1, :operator => :between, :formula => ["1 <> 2","5"] }
+    doc = Nokogiri::XML.parse(@ws.to_xml_string)
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='between']//xmlns:formula='1 <> 2'")
+    assert doc.xpath("//xmlns:worksheet/xmlns:conditionalFormatting//xmlns:cfRule[@type='cellIs'][@dxfId=0][@priority=1][@operator='between']//xmlns:formula='5'")
+  end
+
+  def test_sqref
+    assert_raise(ArgumentError) { @cf.sqref = 10 }
+    assert_nothing_raised { @cf.sqref = "A1:A1" }
+    assert_equal(@cf.sqref, "A1:A1")
+  end
+
+  def test_type
+    assert_raise(ArgumentError) { @cfr.type = "illegal" }
+    assert_nothing_raised { @cfr.type = :containsBlanks }
+    assert_equal(@cfr.type, :containsBlanks)
+  end
+
+  def test_above_average
+    assert_raise(ArgumentError) { @cfr.aboveAverage = "illegal" }
+    assert_nothing_raised { @cfr.aboveAverage = true }
+    assert_equal(@cfr.aboveAverage, true)
+  end
+
+  def test_equal_average
+    assert_raise(ArgumentError) { @cfr.equalAverage = "illegal" }
+    assert_nothing_raised { @cfr.equalAverage = true }
+    assert_equal(@cfr.equalAverage, true)
+  end
+
+  def test_bottom
+    assert_raise(ArgumentError) { @cfr.bottom = "illegal" }
+    assert_nothing_raised { @cfr.bottom = true }
+    assert_equal(@cfr.bottom, true)
+  end
+
+  def test_operator
+    assert_raise(ArgumentError) { @cfr.operator = "cellIs" }
+    assert_nothing_raised { @cfr.operator = :notBetween }
+    assert_equal(@cfr.operator, :notBetween)
+  end
+
+  def test_dxf_id
+    assert_raise(ArgumentError) { @cfr.dxfId = "illegal" }
+    assert_nothing_raised { @cfr.dxfId = 1 }
+    assert_equal(@cfr.dxfId, 1)
+  end
+
+  def test_priority
+    assert_raise(ArgumentError) { @cfr.priority = -1.0 }
+    assert_nothing_raised { @cfr.priority = 1 }
+    assert_equal(@cfr.priority, 1)
+  end
+
+  def test_text
+    assert_raise(ArgumentError) { @cfr.text = 1.0 }
+    assert_nothing_raised { @cfr.text = "testing" }
+    assert_equal(@cfr.text, "testing")
+  end
+
+  def test_percent
+    assert_raise(ArgumentError) { @cfr.percent = "10%" } #WRONG!
+    assert_nothing_raised { @cfr.percent = true }
+    assert_equal(@cfr.percent, true)
+  end
+
+  def test_rank
+    assert_raise(ArgumentError) { @cfr.rank = -1 }
+    assert_nothing_raised { @cfr.rank = 1 }
+    assert_equal(@cfr.rank, 1)
+  end
+
+  def test_std_dev
+    assert_raise(ArgumentError) { @cfr.stdDev = -1 }
+    assert_nothing_raised { @cfr.stdDev = 1 }
+    assert_equal(@cfr.stdDev, 1)
+  end
+
+  def test_stop_if_true
+    assert_raise(ArgumentError) { @cfr.stopIfTrue = "illegal" }
+    assert_nothing_raised { @cfr.stopIfTrue = false }
+    assert_equal(@cfr.stopIfTrue, false)
+  end
+
+  def test_time_period
+    assert_raise(ArgumentError) { @cfr.timePeriod = "illegal" }
+    assert_nothing_raised { @cfr.timePeriod = :today }
+    assert_equal(@cfr.timePeriod, :today)
+  end
+
+end