Redmine

    assert a.save

    assert_equal 'japanese-utf-8.txt', a.filename

    get :show, :params => {

        :id => a.id

      }

    assert_equal 'text/html', @response.content_type

    assert_select 'tr#L1' do

      assert_select 'th.line-num', :text => '1'

    end

  end

          '1' => {

            :filename => 'newname.text',

            :description => ''

                  '4' => {

            :filename => 'newname.rb',

            :description => 'Renamed'

        }

      }

          '1' => {

            :filename => '',

            :description => ''

                  '4' => {

            :filename => 'newname.rb',

            :description => 'Renamed'

        }

      }

  def test_index_csv_big_5

    with_settings :default_language => "zh-TW" do

      issue = Issue.generate!(:subject => str_utf8)

      get :index, :params => {

      assert_equal 'text/csv; header=present', @response.content_type

      lines = @response.body.chomp.split("\n")

      header = lines[0]

      assert_include status, header

      issue_line = lines.find {|l| l =~ /^#{issue.id},/}

      assert_include str_big5, issue_line

  def test_index_csv_cannot_convert_should_be_replaced_big_5

    with_settings :default_language => "zh-TW" do

      issue = Issue.generate!(:subject => str_utf8)

      get :index, :params => {

      lines = @response.body.chomp.split("\n")

      header = lines[0]

      issue_line = lines.find {|l| l =~ /^#{issue.id},/}

      assert header.include?(s1)

      s2 = issue_line.split(",")[2]

      assert_equal s3, s2

    end

  end

  end

  def test_export_to_pdf_with_utf8_u_fffd

    ["en", "zh", "zh-TW", "ja", "ko"].each do |lang|

      with_settings :default_language => lang do

        get :show, :params => {

  REPOSITORY_PATH = Rails.root.join('tmp/test/bazaar_repository').to_s

  REPOSITORY_PATH_TRUNK = File.join(REPOSITORY_PATH, "trunk")

  PRJ_ID = 3

  def setup

    super

        assert_select "th.line-num", :text => '1' do

          assert_select "+ td.revision" do

            assert_select "a", :text => '2'

              assert_select "+ td",

                            :text => "author non ASCII test"

            end

               "when Encoding.default_external is not UTF-8. " +

               "Current value is '#{Encoding.default_external.to_s}'"

        else

        end

      end

    end

  REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s

  REPOSITORY_PATH.gsub!(/\//, "\\") if Redmine::Platform.mswin?

  PRJ_ID     = 3

  NUM_REV = 28

  ## Git, Mercurial and CVS path encodings are binary.

            :is_default => '0',

            :identifier => 'test-create',

            :report_last_commit => '1',

          }

        }

    end

        :id => repository.id,

        :repository => {

          :report_last_commit => '0'

        }

      }

    assert_response 302

            get :entry, :params => {

                :id => PRJ_ID,

                :repository_id => @repository.id,

              :rev => r1

              }

            assert_response :success

          end

        end

      end

                }

              assert_response :success

              assert_select 'table' do

              end

            end

          end

            get :annotate, :params => {

                :id => PRJ_ID,

              :repository_id => @repository.id,

              :rev => r1

              }

            assert_select "th.line-num", :text => '1' do

                assert_select "a", :text => '57ca437c'

                assert_select "+ td.author", :text => "jsmith" do

                  assert_select "+ td",

                end

              end

            end

        assert_select "th.line-num", :text => '1' do

          assert_select "+ td.revision" do

            assert_select "a", :text => '83ca5fd5'

              assert_select "+ td",

                            :text => "And this is a file with a leading and trailing space..."

            end

           :repositories, :enabled_modules

  REPOSITORY_PATH = Rails.root.join('tmp/test/mercurial_repository').to_s

  PRJ_ID     = 3

  NUM_REV    = 34

                      )

    assert @repository

    @diff_c_support = true

  end

  if ruby19_non_utf8_pass

        assert_select 'table.entries tbody' do

          assert_select 'tr', 4

          assert_select 'tr.file td.filename a', :text => "make-latin-1-file.rb"

        end

        assert_select 'table.changesets tbody' do

      assert_equal NUM_REV, @repository.changesets.count

       [

          'default',

          'branch (1)[2]&,%.-3_4',

          'test_branch.latin-1',

          'test-branch-00',

      ].each do |bra|

      @project.reload

      assert_equal NUM_REV, @repository.changesets.count

       [

        'tag_test.00',

        'tag-init-revision'

      ].each do |tag|

        get :entry, :params => {

            :id => PRJ_ID,

            :repository_id => @repository.id,

          :rev => r1

          }

        assert_response :success

          get :entry, :params => {

              :id => PRJ_ID,

              :repository_id => @repository.id,

            :rev => r1

            }

          assert_response :success

        end

      end

    end

              }

            assert_response :success

            assert_select 'table' do

              assert_select 'tbody td.diff_in', :text => /It is written in Python/

            end

          end

        get :annotate, :params => {

            :id => PRJ_ID,

            :repository_id => @repository.id,

          :rev => r1

          }

        assert_response :success

          get :annotate, :params => {

              :id => PRJ_ID,

              :repository_id => @repository.id,

            :rev => r1

            }

        end

      end

    end

  end

  def test_csv_big_5

    user = User.find_by_id(3)

    user.lastname  = "test-lastname"

    assert user.save

    comments = "test_csv_big_5"

    assert_equal 'text/csv; header=present', @response.content_type

    lines = @response.body.chomp.split("\n")

    # Headers

    assert_equal s1, lines.first

    # Total row

    assert_equal "#{str_big5} #{user.lastname},7.30,7.30", lines[1]

    assert_equal "#{s2},7.30,7.30", lines[2]

    assert_equal 'Big5', l(:general_csv_encoding)

    assert_equal ',', l(:general_csv_separator)

    assert_equal '.', l(:general_csv_decimal_separator)

  end

  def test_csv_cannot_convert_should_be_replaced_big_5

    user = User.find_by_id(3)

    user.lastname  = "test-lastname"

    assert user.save

    comments = "test_replaced"

    assert_equal 'text/csv; header=present', @response.content_type

    lines = @response.body.chomp.split("\n")

    # Headers

    assert_equal s1, lines.first

    # Total row

    assert_equal "#{s2} #{user.lastname},7.30,7.30", lines[1]

  end

      assert_equal 'text/csv; header=present', @response.content_type

      lines = @response.body.chomp.split("\n")

      # Headers

      assert_equal s1, lines.first

      # Total row

      assert_equal "#{user.firstname} #{user.lastname};7,30;7,30", lines[1]

      assert_equal "#{s2};7,30;7,30", lines[2]

      assert_equal 'ISO-8859-1', l(:general_csv_encoding)

      assert_equal ';', l(:general_csv_separator)

      assert_equal ',', l(:general_csv_decimal_separator)

  def setup

    super

    set_tmp_attachments_directory

  end

  test "#link_to_if_authorized for authorized user should allow using the :controller and :action for the target link" do

  end

  def test_truncate_single_line_non_ascii

    result = truncate_single_line_raw("#{ja}\n#{ja}\n#{ja}", 10)

    assert_equal "#{ja} #{ja}...", result

    assert !result.html_safe?

  end

  def test_invalid_utf8_credentials_should_not_trigger_an_error

    assert !invalid_utf8.valid_encoding?

    assert_nothing_raised do

      get '/users/current.xml', :headers => credentials(invalid_utf8, "foo")

  end

  def test_latest_attach_should_not_error_with_string_with_invalid_encoding

    assert_equal false, string.valid_encoding?

    Attachment.latest_attach(Attachment.limit(2).to_a, string)

  def test_comments_should_be_converted_to_utf8

    proj = Project.find(3)

    r = Repository::Bazaar.create!(

            :project      => proj,

            :url          => '/tmp/test/bazaar',

                      :scmid        => '12345',

                      :comments     => str)

    assert( c.save )

  end

  def test_invalid_utf8_sequences_in_comments_should_be_replaced_latin1

    proj = Project.find(3)

    r = Repository::Bazaar.create!(

            :project      => proj,

            :url          => '/tmp/test/bazaar',

                      :committed_on => Time.now,

                      :revision     => '123',

                      :scmid        => '12345',

                      :committer    => str2)

    assert( c.save )

    assert_equal "Texte encod? en ISO-8859-1.", c.comments

  def test_invalid_utf8_sequences_in_comments_should_be_replaced_ja_jis

    proj = Project.find(3)

    r = Repository::Bazaar.create!(

            :project      => proj,

            :url          => '/tmp/test/bazaar',

  end

  def test_comments_should_be_converted_all_latin1_to_utf8

    s4 = s2.dup

    s3 = s1.dup

    s1.force_encoding('ASCII-8BIT')

  def test_invalid_utf8_sequences_in_paths_should_be_replaced

    proj = Project.find(3)

    r = Repository::Bazaar.create!(

            :project => proj,

            :url => '/tmp/test/bazaar',

    ch = Change.new(

                  :changeset     => cs,

                  :action        => "A",

                  :from_path     => str2,

                  :from_revision => "345")

    assert(ch.save)

  def test_possible_values_should_return_utf8_encoded_strings

    field = CustomField.new

    field.possible_values = s

    assert_equal [s], field.possible_values

    assert_equal 'UTF-8', field.possible_values.first.encoding.name

  def test_blank_name_error_message_fr

    set_language_if_valid 'fr'

    g = Group.new

    assert !g.save

  end

  def test_group_roles_should_be_given_to_added_user

  def test_to_utf8_by_setting_from_latin1

    with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do

      s3 = s2.dup.force_encoding("UTF-8")

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)

  def test_to_utf8_by_setting_from_euc_jp

    with_settings :repositories_encodings => 'UTF-8,EUC-JP' do

      s3 = s2.dup.force_encoding("UTF-8")

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)

  def test_to_utf8_by_setting_should_be_converted_all_latin1

    with_settings :repositories_encodings => 'ISO-8859-1' do

      s3 = s2.dup.force_encoding("UTF-8")

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s2)

      assert_equal s1, Redmine::CodesetUtil.to_utf8_by_setting(s3)

  end

  def test_to_utf8_by_setting_returns_ascii_as_utf8

    s2 = s1.dup.force_encoding("ISO-8859-1")

    str1 = Redmine::CodesetUtil.to_utf8_by_setting(s1)

    str2 = Redmine::CodesetUtil.to_utf8_by_setting(s2)

  def test_to_utf8_by_setting_invalid_utf8_sequences_should_be_stripped

    with_settings :repositories_encodings => '' do

      str = Redmine::CodesetUtil.to_utf8_by_setting(s1)

      assert str.valid_encoding?

      assert_equal "UTF-8", str.encoding.to_s

  def test_to_utf8_by_setting_invalid_utf8_sequences_should_be_stripped_ja_jis

    with_settings :repositories_encodings => 'ISO-2022-JP' do

      str = Redmine::CodesetUtil.to_utf8_by_setting(s1)

      assert str.valid_encoding?

      assert_equal "UTF-8", str.encoding.to_s

  end

  test "#replace_invalid_utf8 should replace invalid utf8" do

    s2 = Redmine::CodesetUtil.replace_invalid_utf8(s1)

    assert s2.valid_encoding?

    assert_equal "UTF-8", s2.encoding.to_s

  end

  test "#to_utf8 should replace invalid non utf8" do

    s2 = Redmine::CodesetUtil.to_utf8(s1, "EUC-JP")

    assert s2.valid_encoding?

    assert_equal "UTF-8", s2.encoding.to_s

  end

end

class CsvTest < ActiveSupport::TestCase

  include Redmine::I18n

  def test_should_include_bom_when_utf8_encoded

    with_locale 'sk' do

      string = Redmine::Export::CSV.generate {|csv| csv << %w(Foo Bar)}

      assert_equal 'UTF-8', string.encoding.name

    end

  end

  end

  def test_rdm_pdf_iconv_cannot_convert_ja_cp932

    ["CP932", "SJIS"].each do |encoding|

      txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_1, encoding)

      txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_2, encoding)

      txt_3 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_3, encoding)

      assert_equal "ASCII-8BIT", txt_1.encoding.to_s

      assert_equal "ASCII-8BIT", txt_2.encoding.to_s

      assert_equal "ASCII-8BIT", txt_3.encoding.to_s

  end

  def test_rdm_pdf_iconv_invalid_utf8_should_be_replaced_en

    txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str1, 'UTF-8')

    txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str2, 'UTF-8')

    assert_equal "ASCII-8BIT", txt_1.encoding.to_s

  end

  def test_rdm_pdf_iconv_invalid_utf8_should_be_replaced_ja

    encoding = ( RUBY_PLATFORM == 'java' ? "SJIS" : "CP932" )

    txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str1, encoding)

    txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str2, encoding)

    ["CP932", "SJIS"].each do |encoding|

      set_fixtures_attachments_directory

      a1 = Attachment.find(17)

      a2 = Attachment.find(19)

        end

        assert l('date.day_names').is_a?(Array)

        assert_equal 7, l('date.day_names').size

        assert l('date.month_names').is_a?(Array)

        assert_equal 13, l('date.month_names').size

      end

    set_language_if_valid 'bs'

    assert_equal "KM -1000,20", number_to_currency(-1000.2)

    set_language_if_valid 'de'

  end

  def test_lu_should_not_error_when_user_language_is_an_empty_string

    assert_nil options.detect {|option| option.size != 2}

    assert_nil options.detect {|option| !option.first.is_a?(String) || !option.last.is_a?(String)}

    assert_include ["English", "en"], options

  end

  def test_languages_options_should_return_strings_with_utf8_encoding

  def test_utf8

    set_language_if_valid 'ja'

    i18n_ja_yes = l(:general_text_Yes)

    assert_equal "UTF-8", i18n_ja_yes.encoding.to_s

  end

  def test_traditional_chinese_locale

    set_language_if_valid 'zh-TW'

  end

  def test_french_locale

    set_language_if_valid 'fr'

  end

end

class GitAdapterTest < ActiveSupport::TestCase

  REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s

  ## Git, Mercurial and CVS path encodings are binary.

  ## Subversion supports URL encoding for path.

  ## Redmine Mercurial adapter and extension use URL encoding.

                    'ISO-8859-1'

                 )

      assert @adapter

    end

    def test_scm_version

      end

      assert_equal 6, brs.length

      br_issue_8857 = brs[0]

      assert_equal '2a682156a3b6e77a8bf9cd4590e8db757f3c6c78', br_issue_8857.revision

      assert_equal br_issue_8857.scmid, br_issue_8857.revision

      assert_equal false, br_issue_8857.is_default

      br_latin_1_path = brs[1]

      assert_equal '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127', br_latin_1_path.revision

      assert_equal br_latin_1_path.scmid, br_latin_1_path.revision

      assert_equal false, br_latin_1_path.is_default

  HgCommandArgumentError = Redmine::Scm::Adapters::MercurialAdapter::HgCommandArgumentError

  REPOSITORY_PATH = repository_path('mercurial')

  if File.directory?(REPOSITORY_PATH)

    def setup

                            nil,

                           'ISO-8859-1')

      @diff_c_support = true

    end

    def test_hgversion

  end

  def test_utf8_ja

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(read_diff_fixture('issue-12641-ja.diff'), :type => 'inline')

      assert_equal 1, diff.size

      assert_equal 12, diff.first.size

    end

  end

  def test_utf8_ru

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(read_diff_fixture('issue-12641-ru.diff'), :type => 'inline')

      assert_equal 1, diff.size

      assert_equal 8, diff.first.size

    end

  end

  end

  def test_offset_range_japanese_1

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(

               read_diff_fixture('issue-13644-1.diff'), :type => 'sbs')

      assert_equal 1, diff.size

      assert_equal 3, diff.first.size

    end

  end

  def test_offset_range_japanese_2

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(

               read_diff_fixture('issue-13644-2.diff'), :type => 'sbs')

      assert_equal 1, diff.size

      assert_equal 3, diff.first.size

    end

  end

  def test_offset_range_japanese_3

    # UTF-8 The 1st byte differs.

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(

               read_diff_fixture('issue-13644-3.diff'), :type => 'sbs')

      assert_equal 1, diff.size

      assert_equal 3, diff.first.size

    end

  end

  def test_offset_range_japanese_4

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(

               read_diff_fixture('issue-13644-4.diff'), :type => 'sbs')

      assert_equal 1, diff.size

      assert_equal 3, diff.first.size

    end

  end

  def test_offset_range_japanese_5

    with_settings :repositories_encodings => '' do

      diff = Redmine::UnifiedDiff.new(

               read_diff_fixture('issue-13644-5.diff'), :type => 'sbs')

      assert_equal 1, diff.size

      assert_equal 3, diff.first.size

    end

  end

  end

  def test_add_issue_with_japanese_keywords

    Project.find(1).trackers << tracker

    issue = submit_email(

              'japanese_keywords_iso_2022_jp.eml',

            )

    assert_kind_of Issue, issue

    assert_equal 1, issue.attachments.size

    attachment = issue.attachments.first

    assert_equal 5, attachment.filesize

    assert File.exist?(attachment.diskfile)

    assert_equal 5, File.size(attachment.diskfile)

              :issue => {:project => 'ecookbook'}

            )

    assert_kind_of Issue, issue

  end

  def test_gmail_with_attachment_ja

            )

    assert_kind_of Issue, issue

    assert_equal 1, issue.attachments.size

    attachment = issue.attachments.first

    assert_equal 5, attachment.filesize

    assert File.exist?(attachment.diskfile)

    assert_equal 5, File.size(attachment.diskfile)

            )

    assert_kind_of Issue, issue

    assert_equal 1, issue.attachments.size

    11.times { u << u1 }

    attachment = issue.attachments.first

    assert_equal "#{u}.png", attachment.filename

            )

    assert_kind_of Issue, issue

    assert_equal 1, issue.attachments.size

    11.times { u << u1 }

    attachment = issue.attachments.first

    assert_equal "#{u}.txt", attachment.filename

    assert_equal 19, attachment.filesize

    assert File.exist?(attachment.diskfile)

    assert_equal 19, File.size(attachment.diskfile)

    assert_equal content, File.read(attachment.diskfile).force_encoding('CP852')

  end

              'subject_as_iso-8859-1.eml',

              :issue => {:project => 'ecookbook'}

            )

    assert_kind_of Issue, issue

  end

  def test_quoted_printable_utf8

              :issue => {:project => 'ecookbook'}

            )

    assert_kind_of Issue, issue

  end

  def test_gmail_iso8859_2

              :issue => {:project => 'ecookbook'}

            )

    assert_kind_of Issue, issue

  end

  def test_add_issue_with_japanese_subject

              :issue => {:project => 'ecookbook'}

            )

    assert_kind_of Issue, issue

  end

  def test_add_issue_with_korean_body

    issue = submit_email(

            'body_ks_c_5601-1987.eml',

            :issue => {:project => 'ecookbook'}

          )

    assert_kind_of Issue, issue

  end

  def test_add_issue_with_no_subject_header

              :issue => {:project => 'ecookbook'}

            )

    assert_kind_of Issue, issue

  end

  def test_add_issue_with_iso_2022_jp_ms_subject

    end

    user = User.order('id DESC').first

    assert_equal "foo@example.org", user.mail

  end

  def test_new_user_with_fullname_in_parentheses

    member = Member.new(:project_id => 1, :user_id => user.id, :role_ids => [])

    assert !member.save

    assert_include I18n.translate('activerecord.errors.messages.empty'), member.errors[:role]

      [member.errors.full_messages].flatten.join

  end

  def test_label_for_fr

    set_language_if_valid 'fr'

    q = IssueQuery.new

  end

  def test_editable_by

  RUN_LATIN1_OUTPUT_TEST = (RUBY_PLATFORM != 'java' &&

                             Encoding.locale_charmap == "ISO-8859-1")

  def setup

    User.current = nil

  def test_blank_path_to_repository_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Bazaar.new(

                          :project      => @project,

                          :url          => "",

                          :log_encoding => 'UTF-8'

                        )

    assert !repo.save

  end

  if File.directory?(REPOSITORY_PATH_TRUNK)

  def test_blank_module_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Cvs.new(

                          :project       => @project,

                          :identifier    => 'test',

                          :root_url      => REPOSITORY_PATH

                        )

    assert !repo.save

  end

  def test_blank_cvsroot_error_message

  def test_blank_cvsroot_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Cvs.new(

                          :project       => @project,

                          :identifier    => 'test',

                          :root_url      => ''

                        )

    assert !repo.save

  end

  def test_root_url_should_be_validated_against_regexp_set_in_configuration

  def test_blank_root_directory_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Filesystem.new(

                          :project      => @project,

                          :url          => "",

                          :path_encoding => ''

                        )

    assert !repo.save

  end

  if File.directory?(REPOSITORY_PATH)

  NUM_REV = 28

  NUM_HEAD = 6

  ## Git, Mercurial and CVS path encodings are binary.

  ## Subversion supports URL encoding for path.

  ## Redmine Mercurial adapter and extension use URL encoding.

  def test_blank_path_to_repository_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Git.new(

                          :project      => @project,

                          :url          => "",

                          :path_encoding => ''

                        )

    assert !repo.save

  end

  if File.directory?(REPOSITORY_PATH)

      else

        # latin-1 encoding path

        changesets = @repository.latest_changesets(

        assert_equal [

              '64f1f3e89ad1cb57976ff0ad99a107012ba3481d',

              '4fc55c43bf3d3dc2efb66145365ddc17639ce81e',

          ], changesets.collect(&:revision)

        changesets = @repository.latest_changesets(

        assert_equal [

              '64f1f3e89ad1cb57976ff0ad99a107012ba3481d',

          ], changesets.collect(&:revision)

        @project.reload

        assert_equal NUM_REV, @repository.changesets.count

        changesets = @repository.latest_changesets(

        assert_equal [

              '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127',

          ], changesets.collect(&:revision)

      assert_equal NUM_REV, @repository.changesets.count

      c = @repository.changesets.find_by_revision(

                        'ed5bb786bbda2dee66a2d50faf51429dbc043a7b')

    end

    def test_previous

  REPOSITORY_PATH = Rails.root.join('tmp/test/mercurial_repository').to_s

  NUM_REV = 34

  def setup

    User.current = nil

    @project    = Project.find(3)

  def test_blank_path_to_repository_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Mercurial.new(

                          :project      => @project,

                          :url          => "",

                          :path_encoding => ''

                        )

    assert !repo.save

  end

  if File.directory?(REPOSITORY_PATH)

      assert_equal NUM_REV, @repository.changesets.count

      if @repository.scm.class.client_version_above?([1, 6])

        assert_equal %w|27 26|, changesets.collect(&:revision)

      end

      assert_equal %w|27|, changesets.collect(&:revision)

    end

      scmid3 = scmid_for_assert(hex3, is_short_scmid)

      assert_equal 1, c3.size

      assert_equal 'A', c3[0].action

      assert_equal scmid3, c3[0].from_revision

    end

    private :assert_copied_files

    def test_log_encoding_ignore_setting

      with_settings :commit_logs_encoding => 'windows-1252' do

        c = Changeset.new(:repository => @repository,

                          :comments   => s2,

                          :revision   => '123',

  def test_blank_log_encoding_error_message_fr

    set_language_if_valid 'fr'

    repo = Repository::Bazaar.new(

                        :project      => Project.find(3),

                        :url          => "/test"

                      )

    assert !repo.save

  end

  def test_create

                    :url => '/foo/bar/baz' )

    long_whitespace = "                                                "

    expected_comment = "This is a loooooooooooooooooooooooooooong comment"

    3.times {comment << "#{long_whitespace}\n"}

    changeset = Changeset.new(

      :comments => comment, :commit_date => Time.now,

  end

  def test_titleize

    assert_equal 'Page_title_with_CAPITALES', Wiki.titleize('page title with CAPITALES')

    assert_equal ja_test, Wiki.titleize(ja_test)

  end